JPH11305809A - Programmable controller system, programmable controller supporting device, programmable controller and storage medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To reduce the capacities of an initialization pattern file and an attribute information file to be transmitted from a programmable controller supporting device to a programmable controller. SOLUTION: A compile means 1b complies an application program inputted from an application program inputting means 1a. At that time, an initialization variable extracting means 1c extracts an initialization variable, and an initialization pattern file generating means 1d generates an initialization pattern file. Also, a common initialization pattern file generating means 1e generates a common pattern file, and a mapping information generating means 1f generates mapping information. A transmitting means 1g transmits an executable file generated by the compile, initialization pattern file, common initialization pattern file, and mapping information to a programmable controller 3. The initialization pattern file stored in an initialization pattern storing means 3c of the programmable controller 3 is mapped to the prescribed area of a variable value storing means 3e of a mapping means 3d at the time of activation.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to a programmable controller system, a programmable controller support device, a programmable controller, and a recording medium, and more particularly, to a program executable by compiling source code of an application program input from the programmable controller support device. The present invention relates to a programmable controller system that generates and then supplies the program to a programmable controller, executes the programmable controller system and the programmable controller that constitute the programmable controller system, and a recording medium that records a program that causes a computer to function as the programmable controller support device.

[0002]

2. Description of the Related Art A programmable controller (PC: Proglamable) characterized in that control specifications can be easily changed.
Controllers) have come to be used in numerous sites, driven by their lower prices and higher performance.

[0003] Generally, a programmable controller is, like a personal computer, a CPU, an RO, and the like.
It is configured by an M, a RAM, an interface, and the like, and controls a group of modules to be controlled according to an application program supplied from the programmable controller support device.

By the way, an application program executed by a programmable controller is described in a programmable controller support device using, for example, a high-level language or a graphic language. Then, when executing the application program, the program is compiled to generate an executable file, and then the executable file is transmitted to the programmable controller to be executed.

[0005] When compiling an application program, an initialization pattern file storing initial values of various variables used in the application program is generated and transmitted to the programmable controller together with the executable file.

FIG. 12 is a diagram showing an example of an initialization pattern file generated by a conventional programmable controller. In this figure, an application program P1 is a source code.
EC (International Electrotechnical Commission)
It is described in a high-level language conforming to the 1131-3 standard.

Incidentally, the following four types of variables can be used in a high-level language conforming to the IEC1131-3 standard. Note that these variables are classified according to whether or not they have an initial value specified by the user, and the difference in handling of initialization between warm activation and cold activation described later. (1) Normal variable: Initialized to a value of 0 regardless of the activation method. (2) Initialization variable: has a predetermined initial value regardless of the activation method. (3) Retain variable: Initialized to a value of 0 for cold activation. (4) Initialization retain variable: Initialized to a predetermined value in cold start, and the value of the previous execution is held in warm start. Here, warm start Means restarting with the value of the retain variable (including the initialization retain variable) at the time of the previous execution maintained, and cold start means
This is to start with the retain variables initialized.

When the application program P1 is compiled by the programmable controller support device, an executable file (program) is generated, and an initialization pattern file i1 and attribute information a
1 is generated.

Here, the initialization pattern file i1 is
Stores initial values for initializing variables included in application programs. Also, attribute information a1
Indicates whether the variable corresponding to the initial value stored in the initialization pattern file i1 is a retain variable by the state of its bit.

In this example, variables are declared in an area surrounded by "VAR" and "END_VAR" of the application program P1. For example, on the third line, a variable of type "Integer""AA
A "is declared, and its initial value is not defined. In the line below, an integer type variable “BBB” is declared, and its initial value is “444” in hexadecimal.
It should be noted that, among the variables in the area surrounded by “VAR” and “END_VAR”, the variable to which the initial value is not assigned is the normal variable, and the variable to which the initial value is assigned is the initialization variable.

A variable declared in an area surrounded by “VAR RETAINE” and “END_VAR” is a retain variable. For example, on the eighth line, an integer type retain variable “DDD” is declared, and its initial value is “456” in hexadecimal.
Among the variables declared in the area surrounded by “VAR RETAINE” and “END_VAR”, the variable to which the initial value is not assigned is the retain variable, and the variable to which the initial value is assigned is the initialize retain. Variable.

Therefore, the application program P1
Integer type ordinary variable AAA declared in the third line of
Since its initial value is 0, "0" is stored in the first line of the initialization pattern file, and the first line of the memory attribute information indicates that it is not a retain variable. “0” is stored.

The initialization pattern file i1 and the attribute information a1 thus generated are transmitted to the programmable controller and stored therein. Then, for example, when a cold start is performed, as shown in FIG. 13, all of the initialization pattern files are stored in the user memory (memory for storing the values of each variable during execution of the program).
m1.

When the warm start is performed, as shown in FIG. 14, only the attribute information having a value of "0" (variable other than the retain variable) is transferred to the user memory m1. .

Then, the application program is executed, and the control of the control target is started. According to the above configuration, for example, when debugging an application program, the program can be executed in a form suitable for the purpose, such as performing a warm start and checking the operation while appropriately stopping the program.

[0016]

However, in such a conventional method, it is necessary to create an initialization pattern file storing initial values of all variables and to create attribute information corresponding to the initialization pattern file. The capacity of these two files increases. As a result, there is a problem that it takes time to transfer the application program from the programmable controller support device to the programmable controller.

SUMMARY OF THE INVENTION The present invention has been made in view of such a point, and a programmable controller system, a programmable controller support apparatus, and a program which can reduce the file size of an initialization pattern file and attribute information corresponding thereto. It is an object of the present invention to provide a programmable controller and a recording medium recording a program for causing a computer to execute the above-described processing.

[0018]

In order to solve the above-mentioned problems, the present invention compiles the source code of an application program input from a programmable controller support device, generates an executable file, and supplies the executable file to the programmable controller. A programmable controller system, the programmable controller support device comprises: an application program input means for receiving an input of a source code of the application program; and a compiling means for compiling the source code of the application program to generate an executable file And, among variables included in the source code of the application program,
Initialization variable extraction means for discriminating between an initialization variable initialized by a preset initial value and other variables initialized by a value 0, and extracting only the initialization variable and its initial value; Initialization pattern file generation means for generating an initialization pattern file from initial values of the initialization variables extracted by the initialization variable extraction means, executable file generated by the compilation means, and initialization pattern file generation means Transmitting means for transmitting an initialization pattern file generated by the programmable controller to the programmable controller, and starting means for starting the executable file transmitted by the transmitting means,
The programmable controller includes a receiving unit that receives the executable file transmitted from the programmable controller support device, the initialization pattern file, and an executable file that stores the executable file received by the receiving unit. Storage means, initialization pattern file storage means for storing the initialization pattern file received by the reception means, and variable value storage means for storing values of various variables when the executable file is started A mapping unit that maps the initialization pattern file to a predetermined area of the variable value storage unit when the executable file is activated by the activation unit; and a mapping unit that is predetermined by the initialization pattern file. Said initialization initialized by the initial value Programmable controller system characterized by having an initialization means for initializing a predetermined area of the variable value storing means corresponding to the variables other than the number the value 0 is provided.

Here, in the programmable controller support device, the application program input means receives an input of a source code of the application program. The compiling means compiles the source code of the application program to generate an executable file. The initialization variable extracting means discriminates, from among variables included in the source code of the application program, initialization variables initialized by a preset initial value and other variables initialized by a value 0. Then, only the initialization variables and their initial values are extracted. The initialization pattern file generation unit generates an initialization pattern file from the initial values of the initialization variables extracted by the initialization variable extraction unit. The transmitting unit transmits the executable file generated by the compiling unit and the initialization pattern file generated by the initialization pattern file generating unit to the programmable controller. The activation unit activates the executable file transmitted by the transmission unit. In the programmable controller, the receiving means receives the executable file transmitted from the programmable controller support device and the initialization pattern file. The executable file storing unit stores the executable file received by the receiving unit. The initialization pattern file storage unit stores the initialization pattern file received by the reception unit. The variable value storage means stores values of various variables when the executable file is started. The mapping unit maps the initialization pattern file to a predetermined area of the variable value storage unit when the executable file is activated by the activation unit. The initialization means initializes a predetermined area of the variable value storage means corresponding to a variable other than the initialization variable initialized by an initialization value predetermined by the initialization pattern file with a value of 0.

Further, in a programmable controller support apparatus for compiling an input source code of an application program to generate an executable file and then supplying the executable file to a programmable controller for execution, the input of the source code of the application program is received. Application program input means;
Compiling means for compiling the source code of the application program to generate an executable file, and initialization variables initialized by a preset initial value among variables included in the source code of the application program And other variables initialized by the value 0, and initializing variable extracting means for extracting only the initializing variables and their initial values, and initializing the initializing variables extracted by the initializing variable extracting means. An initialization pattern file generating means for generating an initialization pattern file from values, an executable file generated by the compiling means, and an initialization pattern file generated by the initialization pattern file generating means to the programmable controller. Transmitting means for transmitting;
And a starting unit for starting the executable file transmitted by the transmitting unit.

Here, the application program input means receives an input of a source code of the application program. The compiling means compiles the source code of the application program to generate an executable file. The initialization variable extracting means discriminates, from among variables included in the source code of the application program, initialization variables initialized by a preset initial value and other variables initialized by a value 0. Then, only the initialization variables and their initial values are extracted. The initialization pattern file generation unit generates an initialization pattern file from the initial values of the initialization variables extracted by the initialization variable extraction unit. The transmitting unit transmits the executable file generated by the compiling unit and the initialization pattern file generated by the initialization pattern file generating unit to the programmable controller. The activation unit activates the executable file transmitted by the transmission unit.

Further, in a programmable controller in which the programmable controller support apparatus inputs and executes an executable file generated by compiling the source code of an application program, the executable file transmitted from the programmable controller support apparatus; Receiving means for receiving an initialization pattern file, executable file storage means for storing the executable file received by the receiving means, and initialization for storing the initialization pattern file received by the receiving means Pattern file storage means, variable value storage means for storing values of various variables when the executable file is activated, and initialization when the executable file is activated by the activation means Pattern Mapping means for mapping a file to a predetermined area of the variable value storage means, and the variable value storage means corresponding to a variable other than the initialization variable initialized by an initial value predetermined by the initialization pattern file. And initialization means for initializing a predetermined area with a value of 0.

Here, the receiving means includes: an executable file transmitted from the programmable controller support device;
Receive the initialization pattern file. The executable file storing unit stores the executable file received by the receiving unit. The initialization pattern file storage unit stores the initialization pattern file received by the reception unit. The variable value storage means stores values of various variables when the executable file is started. The mapping unit maps the initialization pattern file to a predetermined area of the variable value storage unit when the executable file is activated by the activation unit. The initialization means initializes a predetermined area of the variable value storage means corresponding to a variable other than the initialization variable initialized by an initialization value predetermined by the initialization pattern file with a value of 0.

[0024]

Embodiments of the present invention will be described below with reference to the drawings. In FIG. 1, a programmable controller support device 1 compiles an application program, generates an initialization pattern file, and
To supply.

When the application program is started, the programmable controller 3 sets the initial values of the variables described in the application program according to the initialization pattern file supplied from the programmable controller support device 1, and then executes the program. I do.

The programmable controller 3 controls the modules 5-1 to 5-n to be controlled according to the application program. Here, the programmable controller support device 1 includes an application program input unit 1a, a compiling unit 1b, an initialization variable extraction unit 1c, an initialization pattern file generation unit 1d, a common initialization pattern file generation unit 1e, a mapping information generation unit 1f, Transmission means 1g and activation means 1h
It is constituted by.

Application program input means 1a
Receives input of an application program. The compiling means 1b compiles a program input from the application program input means 1a and generates an executable file.

The initialization variable extracting means 1c extracts an initialization variable and an initialization retain variable from among variables included in the source code of the application program, and extracts their initial values.

The initialization pattern file generating means 1d includes:
An initialization pattern file is generated from the initialization variables extracted by the initialization variable extraction unit 1c and the initial values of the initialization retain variables.

Common initialization pattern file generating means 1e
Extracts a common initialization pattern and generates a common initialization pattern file when a declaration statement having a common initialization pattern appears repeatedly in the source code of the application program.

The mapping information generating means 1f generates mapping information referred to when the common initialization pattern file is mapped by the mapping means 3d described later.

The transmitting means 1g includes an executable file generated by the compiling means 1b, an initialization pattern file generated by the initialization pattern file generating means 1d, and a common initialization generated by the common initialization pattern file generating means 1e. Pattern files, and
The mapping information generated by the mapping information generating means 1f is transmitted to the programmable controller 3.

The starting unit 1h sends a predetermined control signal to the programmable controller 3 to start an application program. The programmable controller 3 includes a receiving unit 3a, an executable file storage unit 3
b, initialization pattern file storage means 3c, mapping means 3d, variable value storage means 3e, and initialization means 3
f.

The receiving means 3a receives the executable file, the initialization pattern file, the common initialization pattern file, and the mapping information transmitted from the programmable controller support device 1.

The executable file storing means 3b stores the executable file received by the receiving means 3a. The initialization pattern file storage unit 3c stores the initialization pattern file, the common initialization pattern file, and the mapping information received by the reception unit 3a.

When the executable file is activated by the activation unit 1h, the mapping unit 3d maps the initialization pattern file to a specific area of the variable value storage unit 3e, and refers to the mapping information to execute the common initial file. The initialization pattern file is mapped to a specific area (an area different from the area where the initialization pattern file is mapped) of the variable value storage unit 3e.

The variable value storage means 3e stores the values of various variables when the application program stored in the executable file storage means 3b is started. The initialization means 3f initializes a normal variable and a retain variable with a value of 0.

Next, the operation of the above principle diagram will be described. Now, assuming that the application program is input from the application program input unit 1a and the compiling unit 1b starts compiling, the initialization variable extracting unit 1c refers to the compilation result of the compiling unit 1b and reads the initialization variable from the application program. (And initialization retain variables).

The initialization variables extracted by the initialization variable extraction unit 1c are stored in the initialization pattern file generation unit 1d.
, Where it is converted to an initialization pattern file. That is, the initialization pattern file generating means 1d
An initialization pattern file including only the initial values of the initialization variables and the initialization retain variables is generated.

The common initialization pattern file generating means 1e extracts a common initialization pattern that appears repeatedly in the application program and generates a common initialization pattern file. The common initialization pattern is
For example, it appears when a function or subroutine having only an initial value is repeatedly used in an application program.

The mapping information generating means 1f generates and outputs information necessary for mapping the common initialization pattern file by the mapping means 3d (information on addresses to be mapped, the number of times of mapping repetition, etc.).

The transmitting unit 1g is an executable file of the application program generated by the compiling unit 1b, an initialization pattern file generated by the initialization pattern file generating unit 1d, and generated by the common initialization pattern file generating unit 1e. The common initialization pattern file and the mapping information generated by the mapping information generating means 1f are transmitted to the programmable controller 3.

The receiving means 3a of the programmable controller 3 receives the above information transmitted from the programmable controller support device 1. The executable file storage unit 3b extracts and stores an executable file from the information received by the receiving unit 3a.

The initialization pattern file storage means 3c
From the information received by the receiving means 3a, an initialization pattern file, a common initialization pattern file, and mapping information are extracted and stored.

In such a state, when the starting means 1h of the programmable controller support device 1 transmits a control signal for starting the application program, the application program stored in the executable file storing means 3b is started. Will be.

At this time, the mapping means 3d maps the initialization pattern file stored in the initialization pattern file storage means 3c to a specific area of the variable value storage means 3e, and refers to the mapping information for common areas. The initialization pattern file is mapped to a specific area of the variable value storage unit 3e different from the area to which the initialization pattern file is mapped.

For example, if the mapping information indicates that the common initialization pattern file is to be mapped repeatedly five times, the mapping means 3d continuously reads the common initialization pattern file from a specific address five times. Map.

The initialization means 3f writes "0" in the area of the variable value storage means 3e where the normal variables and the retain variables are stored, and initializes these variables to the value 0. And
When the application program stored in the executable file storage unit 3b actually starts operating, the module 5 to be controlled via the bus 4 is referenced while appropriately referring to the variable values stored in the variable value storage unit 3e. −
1 to 5-n will be controlled.

According to the present invention described above, initialization variables are extracted from an application program, an initialization pattern file necessary for initializing them is generated, and a specific area of the variable value storage means 3e is specified. , It is not necessary to transmit all the initial values. As a result, the programmable controller support device 1
Can reduce the capacity of a file transmitted to the programmable controller 3.

The common initialization pattern is extracted from the application program and transmitted to the programmable controller 3 together with the mapping information. The programmable controller 3 refers to the mapping information and stores the common initialization pattern in the variable value storage means 3e. Since the mapping is performed, if the same initialization pattern repeatedly appears in the application program, only one common pattern can be transmitted. It is possible to reduce the capacity of the file transmitted from 1 to the programmable controller 3.

Next, an embodiment of the present invention will be described with reference to FIG. As shown in this figure, the programmable controller support device 20 includes a CPU 20a, a ROM
20b, RAM 20c, interfaces 20d, 20
e, compiles an application program input from the input device 10, generates an initialization pattern file of variables included in the application program, and transmits the generated initialization pattern file to the programmable controller 30. In addition, it controls the programmable controller 30 as needed to activate an application program.

The programmable controller 30 has a CP
U30a, ROM 30b, RAM 30c, interfaces 30d and 30e, and according to the application program transmitted from the programmable controller support device 20, the modules 5-1 to 5-
control n.

Here, the input device 10 is, for example, a keyboard or an HDD device, and supplies an application program to the programmable controller support device 20.

Programmable controller support device 20
CPU 20a controls various parts of the apparatus and performs predetermined arithmetic processing. The ROM 20b stores basic programs executed by the CPU 20a. The RAM 20c temporarily stores data being calculated, programs being executed, and the like when the CPU 20a performs a predetermined process.

The interface 20d is, for example, a US
B (Universal Serial Bus) and SCSI (Small Comput
er System Interface) for inputting an application program from the input device 10. Interface 20d is RS (Recommended Standard) 232C
The serial bus is used to transmit an application program or an initialization pattern file created in the programmable controller support device 20 to the programmable controller 30 or to transmit an operation state of the programmable controller 30 to the programmable controller support device 20.

The bus 4 is connected to the programmable controller 3
0 and the modules 5-1 to 5-n are interconnected, and data can be exchanged between them. Module 5-1
5-n is a device for directly controlling the control target, and is constituted by, for example, a digital input / output, an analog input / output, and a communication device.

Next, the operation of the above embodiment will be described with reference to FIG. FIG. 3 is a flowchart illustrating an example of a process performed in the programmable controller support device 20 illustrated in FIG. When this flowchart is started, the following processing is executed. [S1] The CPU 20a inputs an application program from the input device 10 and stores the application program in a predetermined area of the RAM 20c. [S2] The CPU 20a determines whether a predetermined command is input from the input device 10 and an instruction to execute the compilation is issued. If the execution of the compilation is instructed, the process proceeds to step S3. Returns to step S2. [S3] The CPU 20a executes a compiling process.

This compile processing is performed, for example, by using R
It is executed according to a compiler program stored in the AM 20c. [S4] The CPU 20a extracts an initialization variable included in the application program.

FIG. 4 shows how the initialization variables are extracted.
The user program 40 shown in this figure is a part of the application program together with the user program shown in FIG. 5, and is a part that is executed only once when the program is started.

In this figure, "VAR" and "EN"
Among the portions surrounded by “D_VAR”, those to which an initial value is assigned (variable “BBB” and variable “CC”
C ") are initialization variables extracted in step S4. [S5] The CPU 20a generates an initialization pattern file corresponding to the initialization variables extracted in step S4.

In the example of FIG. 4, the initialization pattern file 4
1 is generated. [S6] The CPU 20a extracts an initialization retain variable included in the application program.

In this figure, “VAR RETAI”
N ”and“ END_VAR ”, the variable to which the initial value is assigned (variable“ DD ”)
D ", the variable" EEE ", and the variable" FFF ") are the initialization retained variables extracted in step S6.

Here, "F_1: funcA" is a statement declaring a function block (the details of which will be described later) whose instance (initialization area) name is "F_1". [S7] The CPU 20a generates an initialization pattern file corresponding to the initialization retain variable extracted in step S6.

In the example of FIG. 4, the initialization pattern file 4
2 is generated. [S8] The CPU 20a extracts a common initialization pattern from the function block and generates a common initialization pattern file.

Here, the function block refers to a functional block that, when a predetermined input is given, executes a predetermined process according to the input, and outputs an obtained result. This is equivalent to, for example, a subroutine or a function.

In this example, as shown in FIG. 4, three function blocks “funcA” having instance names “F_1” to “F_3” are declared in the main block of the user program 40, and those function blocks are declared. The block is, as shown from the 16th line onward,
The variable AAA to which the input parameter is substituted is called by substituting the initial value “123” (for example, F
— 1 (AAA: = 123)).

For example, the sentence "DDD: = F_1.F
“FF” is a process of inputting the value of the output parameter “FFF” of the function block “funcA” having the instance name F_1 to the variable DDD.

The function block "fu"
Since the variables used in “ncA” are common regardless of the instance name, when the application program is executed, a common initialization pattern is stored three times in the user memory area corresponding to these function blocks. Will be mapped.

As described above, when the same function block having a different instance name exists, in step S8, the common initialization pattern is extracted and the common initialization pattern file 51 (see FIG. 5) is generated. Is done. [S9] The CPU 20a generates mapping information.

In the example of FIG. 5, the common initialization pattern of the function block “funcA” is the address “0”.
It is shown that mapping is performed three times consecutively from the address “0001200”. [S10] The CPU 20a generates attribute information.

Here, the attribute information is bit information indicating whether or not a variable (stored in word units) stored in the common initialization pattern file is a retain variable. When the bit is “1”, it indicates that the corresponding information is the initial value of the retain variable.

In the example of FIG. 5, the fifth and sixth lines are “1”, and “045” of the common initialization pattern file is set.
It can be seen that "6" and "0567" are the initial values of the retain variables, which correspond to the variables DDD and EEE described in the tenth to eleventh lines of the user program 50. [S11] The CPU 20a transmits the generated executable file, initialization pattern file, common initialization pattern file, mapping information, and attribute information to the programmable controller 30.

With the above processing, an executable file, an initialization pattern file, a common initialization pattern file, mapping information, and attribute information necessary for executing the application program are generated and supplied to the programmable controller 30. .

Next, an example of processing executed in the programmable controller 30 will be described with reference to FIGS. FIG. 6 is a flowchart illustrating an example of a process executed by the programmable controller 30 when the application program transmitted from the programmable controller support device 20 is executed. When this flowchart is started, the following processing is executed. [S21] The CPU 30a determines whether or not the activation of the application program is requested by the programmable controller support device 20. If the activation is requested, the process proceeds to step S22. In other cases, the process returns to step S21. [S22] The CPU 30a determines whether or not a warm start has been requested. If the warm start has been requested, the process proceeds to step S23. Otherwise (if a cold start has been requested), the process proceeds to step S24. move on. [S23] The CPU 30a executes a warm start process.

The details of this process will be described later with reference to FIG. [S24] The CPU 30a executes a cold activation process. The details of this process will be described later with reference to FIG.

FIG. 7 is a flowchart illustrating details of the warm start process shown in FIG. When this flowchart is started, the following processing is executed. [S31] The CPU 30a initializes the normal memory area with the value 0.

The normal memory area is an area on the RAM 30c in which normal variables are stored. That is, the RAM 30
User memory area of c (area where variable values are stored)
As shown in FIG. 9, a normal memory area 61 for storing values of normal variables, an initialization memory area 62 for storing values of initialization variables, a retain memory area 63 for storing values of retain variables, Initialized retain memory area 64 for storing values of initialized retain variables, and free memory area 6 for storing values of function block variables
It is divided into five. [S32] The CPU 30a sets the initialization pattern file 4
1 is mapped to the initialization memory area 62.

FIG. 10 shows this state. As shown in this example, the initialization pattern file 41 of the initialization variables is mapped to the initialization memory area (the area where the values of the initialization variables are stored) 62 of the user memory area. [S33] The CPU 30a refers to the mapping information 52 and the attribute information 53 and refers to the common initialization pattern file 5
1 is mapped to the free memory area 65.

That is, as shown in FIG.
Is attribute information "0" with reference to the mapping information 52.
Then, the initial value of the common initialization pattern file is written into an area corresponding to the variables (normal variables and initialization variables), and initialization is performed. [S34] The CPU 30a executes the application program stored in the RAM 30c, and returns to the processing in FIG.

By the above processing, the application program can be restarted in a state where the last values of the retain variables and the initialized retain variables (the last values of the variables at the time of the previous activation) are stored.

Next, a detailed description will be given of the cold start processing shown in FIG. 6 with reference to FIG. When the flowchart shown in FIG. 8 starts, the following processing is executed. [S41] The CPU 30a initializes the normal memory area 61 and the retain memory area 63 with the value 0. [S42] The CPU 30a initializes the initialization pattern file 4
1 is mapped to the initialization memory area 62.

That is, as shown in FIG.
Maps the initialization pattern file 41 of the initialization variables to the initialization memory area 62 of the user memory area. [S43] The CPU 30a sets the initialization pattern file 4
2 is mapped to the initialization retain memory area 64.

That is, as shown in FIG.
Is the initialization pattern file 42 of the initialization retain variable.
Is mapped to the initialization memory area 64 of the user memory area. [S44] The CPU 30a refers to the mapping information 52 and maps the common initialization pattern file 51 to the free memory area 65.

That is, as shown in FIG.
Maps the common initialization pattern file 51 storing the initial values of all the variables of the function block to the free memory area 65 of the user memory area with reference to the mapping information 52. [S45] The CPU 30a executes the application program stored in the RAM 30c, and returns to the processing in FIG.

With the above processing, the application program can be started with all variables initialized. According to the above embodiment, when compiling an application program in the programmable controller support device 20, an initialization pattern file of an initialization variable and an initialization retain variable is generated,
In the programmable controller 30, the variables are initialized by these initialization pattern files, and the other variables are collectively initialized to a value of 0. Therefore, the programmable controller support device 20 transmits the variables to the programmable controller 30. It is possible to reduce the capacity of the initialization pattern file and the attribute information.

According to the present embodiment, when a plurality of function blocks having different instance names exist in an application program,
While generating the common initialization pattern file 51,
Since the mapping information 52 is generated and the common initialization pattern file 51 is developed in the free memory area 65 with reference to the mapping information 52, the programmable controller 30 transmits the common initialization pattern file 51 from the programmable controller support device 20 to the programmable controller 30. It is possible to reduce the capacity of the initialization pattern file and attribute information to be performed.

Further, according to the present embodiment, when the warm start is executed, the retain variable and the initialization retain variable are not initialized, so that the start mode of the application program can be changed according to the purpose. Can be changed.

Note that the above processing functions can be realized by a computer. In that case, the processing contents of the functions that the programmable controller support device should have are:
The program is described in a program recorded on a computer-readable recording medium, and the above processing is realized by the computer by executing the program on the computer. Examples of the computer-readable recording medium include a magnetic recording device and a semiconductor memory.

For distribution in the market, a CD-ROM
(Compact Disk Read Only Memory) or a program stored in a portable recording medium such as a floppy disk and distributed, or stored in a storage device of a computer connected via a network and transferred to another computer via the network You can also. When the program is executed by the computer, the program may be stored in a hard disk device or the like in the computer, loaded into the main memory, and executed.

[0090]

As described above, according to the present invention, when compiling an application program in a programmable controller support device, an initialization pattern file of a variable initialized by a preset initial value is generated, and Then, the variables are initialized by using these initialization pattern files, and the other variables are collectively initialized to a value of 0. Therefore, the initialization pattern file transmitted from the programmable controller support device to the programmable controller is initialized. In addition, the capacity of attribute information can be reduced.

According to the present embodiment, when a declaration statement having a common initialization pattern appears repeatedly in an application program, a common initialization pattern file is generated and mapping information is generated. In the programmable controller, the common initialization pattern file is mapped with reference to the mapping information, so that the capacity of the initialization pattern file and the attribute information transmitted from the programmable controller support device to the programmable controller can be reduced. It becomes possible.

Further, according to the present embodiment, when the warm start is executed, the retain variables are not initialized, so that the start form of the application program can be changed according to the purpose. .

[Brief description of the drawings]

FIG. 1 is a principle diagram illustrating the principle of the present invention.

FIG. 2 is a block diagram illustrating a configuration example of an embodiment of the present invention.

FIG. 3 is a flowchart illustrating an example of a process executed in the programmable controller support device illustrated in FIG. 2;

FIG. 4 is a diagram illustrating an example of an initialization pattern file of initialization variables generated by the processing of FIG. 3 and an initialization pattern file of initialization retention variables.

FIG. 5 is a diagram illustrating an example of a common initialization pattern file, mapping information, and attribute information generated by the processing of FIG. 3;

FIG. 6 is a flowchart illustrating an example of a process performed by the programmable controller illustrated in FIG. 2;

FIG. 7 is a flowchart illustrating details of a warm start process shown in FIG. 6;

FIG. 8 is a flowchart illustrating details of a cold start process shown in FIG. 6;

FIG. 9 is a diagram showing a manner of dividing a user memory area on a RAM shown in FIG. 2;

FIG. 10 illustrates a case where the processing illustrated in FIG. 7 is performed.
FIG. 4 is a diagram illustrating an example of initialization of a user memory area.

FIG. 11 illustrates a case where the process illustrated in FIG. 8 is performed.
FIG. 4 is a diagram illustrating an example of initialization of a user memory area.

FIG. 12 is a diagram showing an example of a conventional method for generating an initialization pattern file and attribute information.

FIG. 13 is a diagram showing a state in which an initialization pattern file is mapped to a user memory when a conventional cold start is performed.

FIG. 14 is a diagram showing a state in which an initialization pattern file is mapped to a user memory at the time of a conventional warm start.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 Programmable controller support apparatus 1a Application program input means 1b Compiling means 1c Initialization variable extraction means 1d Initialization pattern file generation means 1e Common initialization pattern file generation means 1f Mapping information generation means 1g Transmission means 1h Startup means 2 Bus 3 Programmable controller 3a Receiving unit 3b Executable file storage unit 3c Initialization pattern file storage unit 3d Mapping unit 3e Variable value storage unit 3f Initialization unit 4 Bus 5-1 to 5-n module

Claims (7)

[Claims] 1. A programmable controller system that compiles a source code of an application program input from a programmable controller support apparatus, generates an executable file, and supplies the executable file to a programmable controller for execution. Application program input means for receiving an input of the source code of the application program; compiling means for compiling the source code of the application program to generate an executable file; and a variable included in the source code of the application program. Among them, an initialization variable initialized by a preset initial value and another variable initialized by a value 0 are discriminated, and the Initialization variable extraction means for extracting only the initial value of the initialization variable; initialization pattern file generation means for generating an initialization pattern file from the initial values of the initialization variables extracted by the initialization variable extraction means; Transmitting means for transmitting the generated executable file and the initialization pattern file generated by the initialization pattern file generating means to the programmable controller; and activating means for activating the executable file transmitted by the transmitting means The programmable controller comprises: a receiving unit that receives the executable file transmitted from the programmable controller support device, the initialization pattern file; and the executable file received by the receiving unit. Executable files to store File storage means; initialization pattern file storage means for storing the initialization pattern file received by the reception means; variable value storage for storing values of various variables when the executable file is started Means, when the executable file is activated by the activation means, a mapping means for mapping the initialization pattern file to a predetermined area of the variable value storage means; and Initialization means for initializing a predetermined area of the variable value storage means corresponding to a variable other than the initialization variable initialized by the initial value with a value 0. 2. The method according to claim 1, wherein the activation unit restarts the executable file in a state where the variable values of the retain variables are stored among the various variable values stored in the variable value storage unit; The executable file is started by one of cold starts that starts the executable file in a state where values of all variables stored in the value storage unit are initialized, and the mapping unit executes the warm start. The programmable controller according to claim 1, wherein when executed, a variable value other than the retain variable is mapped, and when the cold start is executed, the entire initialization pattern file is mapped. system. 3. When the declaration statement having a common initialization pattern repeatedly appears in the source code of the application program, the programmable controller support apparatus extracts the common initialization pattern,
A common initialization pattern file generation unit that generates a common initialization pattern file; and a mapping information generation unit that generates mapping information referred to when the common initialization pattern file is mapped by the mapping unit. 2. The programmable controller system according to claim 1, wherein the mapping means of the programmable controller maps the common initialization pattern file with reference to the mapping information. 4. The attribute information for generating attribute information indicating whether or not each of a group of variables having an initialization pattern generated by the common initialization pattern file generating means is a retain variable. Further comprising: generating means, wherein the starting means, among the various variable values stored in the variable value storage means, a warm start that restarts the executable file in a state where the variable values of the retain variables are stored; Activating the executable file by either one of cold activation that activates the executable file with all variable values stored in the variable value storage means initialized, and the mapping means of the programmable controller. Refers to the attribute information when the warm start is executed, and Extracting and mapping the variable values other than the common initialization pattern file from the common initialization pattern file, and, when the cold start is executed, mapping the common initialization pattern file with reference to the attribute information. The programmable controller system according to claim 3, wherein 5. A programmable controller support apparatus for compiling an input source code of an application program to generate an executable file, supplying the executable file to a programmable controller, and executing the executable file, receiving an input of the source code of the application program. Application program input means; compile means for compiling the source code of the application program to generate an executable file; and initializing by a preset initial value among variables included in the source code of the application program. Initialization variable extracting means for discriminating initialization variables to be initialized from other variables initialized by the value 0, and extracting only initialization variables and their initial values, and extraction by the initialization variable extraction means. Initialization pattern file generation means for generating an initialization pattern file from the initial values of the initialized variables, an executable file generated by the compilation means, and an initialization pattern generated by the initialization pattern file generation means A programmable controller support device, comprising: transmitting means for transmitting a file to the programmable controller; and activating means for activating the executable file transmitted by the transmitting means. 6. A computer-readable recording medium storing a program for compiling a source code of an input application program to generate an executable file, and then supplying the program to a programmable controller and causing the computer to execute the processing. An application program input unit that receives an input of the source code of the application program; a compiling unit that compiles the source code of the application program to generate an executable file; included in the source code of the application program Of variables that are initialized by a preset initial value and other variables that are initialized by a value 0, the initialization variable and its initial value are discriminated. Initialization variable extraction means for extracting an initialization pattern file, initialization pattern file generation means for generating an initialization pattern file from initial values of the initialization variables extracted by the initialization variable extraction means, executable file generated by the compilation means A transmission unit for transmitting the initialization pattern file generated by the initialization pattern file generation unit to the programmable controller; and a start unit for starting an executable file transmitted by the transmission unit. Computer readable recording medium. 7. A programmable controller which inputs and executes an executable file generated by compiling a source code of an application program by the programmable controller support device, wherein the executable file transmitted from the programmable controller support device, Receiving means for receiving an initialization pattern file; executable file storage means for storing the executable file received by the receiving means; and initialization for storing the initialization pattern file received by the receiving means. Pattern file storage means; variable value storage means for storing values of various variables when the executable file is activated; and initialization when the executable file is activated by the activation means. Pattern fa Mapping means for mapping a variable to a predetermined area of the variable value storage means, and the variable value storage means corresponding to a variable other than the initialization variable initialized by an initial value predetermined by the initialization pattern file. And initialization means for initializing a predetermined area of the programmable controller with a value of 0.