JP3629947B2 - Programmable controller system, programmable controller support apparatus, programmable controller, and recording medium - Google Patents

Description

[0001]
BACKGROUND OF THE INVENTION
The present invention relates to a programmable controller system, a programmable controller support device, a programmable controller, and a recording medium, and more particularly, after generating an executable file by compiling a source code of an application program input from the programmable controller support device, the programmable controller The present invention relates to a programmable controller system that is supplied to and executed by a programmable controller, a programmable controller support device and a 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]
[Prior art]
A programmable controller (PC) characterized in that the control specifications can be easily changed has been used in many fields, driven by its low price and high performance.
[0003]
In general, a programmable controller is configured by a CPU, a ROM, a RAM, an interface, and the like, similar to a personal computer, and is a group of modules to be controlled according to an application program supplied from a programmable controller support device. To control.
[0004]
By the way, the application program executed by the programmable controller is described in the programmable controller support apparatus using, for example, a high-level language or a graphic language. When executing the application program, the executable program is generated by compiling the program, and the executable file is transmitted to the programmable controller for execution.
[0005]
When compiling the 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.
[0006]
FIG. 12 is a diagram illustrating an example of an initialization pattern file generated by a conventional programmable controller.
In this figure, an application program P1 is a source code, and in this example, it is described in a high-level language that conforms to the IEC (International Electrotechnical Commission) 1131-3 standard.
[0007]
By the way, there are the following four types of variables that can be used in a high-level language conforming to the IEC1131-3 standard. These variables are classified according to whether or not they have an initial value specified by the user and differences in handling of initialization in warm activation and cold activation described later.
(1) Normal variable: Initialized to 0 regardless of the startup method
(2) Initialization variable: has a predetermined initial value regardless of the startup method
(3) Retain variable: Initialized to 0 for cold start, and retains the previous value for warm start
(4) Initialization retain variable: Initialized to a predetermined value at cold start, and the value at the previous execution is held at warm start
Here, the warm start is restarting while retaining the values of the retain variables (including initialization retain variables) at the previous execution, and the cold start is the state where the retain variables are initialized. Is to start with.
[0008]
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 a1 are generated.
[0009]
Here, the initialization pattern file i1 stores initial values for initializing variables included in the application program. The attribute information a1 indicates whether or not the variable corresponding to the initial value stored in the initialization pattern file i1 is a retain variable by the state of the bit.
[0010]
In this example, variables are declared in an area surrounded by “VAR” and “END_VAR” of the application program P1. For example, in the third line, an integer type variable “AAA” is declared and its initial value is not defined. An integer type variable “BBB” is declared in the lower line, and its initial value is “444” in hexadecimal. Of the variables surrounded by “VAR” and “END_VAR”, variables that are not assigned initial values are normal variables, and variables that are assigned initial values are initialization variables.
[0011]
A variable declared in an area surrounded by “VAR RETAIN” and “END_VAR” is a retain variable. For example, in the eighth line, an integer type retain variable “DDD” is declared, and its initial value is “456” in hexadecimal. Of the variables declared in the area enclosed by “VAR RETAIN” and “END_VAR”, the variables to which the initial values are not assigned are the retain variables, and the variables to which the initial values are assigned are the initialization retains. Is a variable.
[0012]
Therefore, since the initial value of the integer type normal variable AAA declared in the third line of the application program P1 is 0, “0” is stored in the first line of the initialization pattern file. In the first row of the memory attribute information, “0” indicating that it is not a retain variable is stored.
[0013]
The initialization pattern file i1 and the attribute information a1 generated in this way are transmitted to the programmable controller and stored therein.
For example, when a cold start is applied, as shown in FIG. 13, all of the initialization pattern file is transferred to the user memory (a memory for storing the value of each variable during program execution) m1.
[0014]
When warm activation is performed, as shown in FIG. 14, only the attribute information value “0” (variable other than the retain variable) is transferred to the user memory m1.
[0015]
Then, the application program is executed, and control on the controlled object is started.
According to the configuration as described above, for example, when the application program is debugged, the program can be executed in a form according to the purpose, such as performing warm activation and checking the operation while appropriately stopping the program.
[0016]
[Problems to be solved by the invention]
However, in such a conventional method, it is necessary to create an initialization pattern file storing the initial values of all variables and to create attribute information corresponding to the initialization pattern file, and 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.
[0017]
The present invention has been made in view of such points, and a programmable controller system, a programmable controller support device, a programmable controller, which can reduce the file capacity of the initialization pattern file and the attribute information corresponding to the initialization pattern file, Another object of the present invention is to provide a recording medium that records a program that causes a computer to execute the above-described processing.
[0018]
[Means for Solving the Problems]
In the present invention, in order to solve the above-described problem, in the programmable controller system for executing the source code of the application program input from the programmable controller support device by compiling the source code of the application program and generating the executable file, the program is supplied to the programmable controller. The programmable controller support device includes an application program input unit that receives input of a source code of the application program, a compile unit that compiles the source code of the application program to generate an executable file, and a source code of the application program. Among the included variables, an initialization variable that is initialized with a preset initial value and other variables that are initialized with a value of 0 Separately, an initialization variable extraction unit that extracts only an initialization variable and its initial value, and an initialization pattern file generation that generates an initialization pattern file from the initial value of the initialization variable extracted by the initialization variable extraction unit Means, an executable file generated by the compiling means, a transmission means for transmitting the initialization pattern file generated by the initialization pattern file generation means to the programmable controller, and an execution transmitted by the transmission means And an activation unit that activates the executable file, and the programmable controller receives the executable file transmitted from the programmable controller support device and the initialization pattern file, and the reception unit receives the executable file. The executable file The executable file storage means for storing, the initialization pattern file storage means for storing the initialization pattern file received by the receiving means, and the values of various variables are stored when the executable file is activated. Variable value storage means, mapping means for mapping the initialization pattern file to a predetermined area of the variable value storage means when the executable file is activated by the activation means, and the initialization pattern file Initialization means for initializing a predetermined area of the variable value storage means corresponding to a variable other than the initialization variable initialized with a predetermined initial value by a value of 0. A programmable controller system is provided.
[0019]
Here, in the programmable controller support device, the application program input means receives the input of the 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 extraction means discriminates among the variables included in the source code of the application program from the initialization variable initialized by a preset initial value and other variables initialized by the value 0 Only the initialization variable and its initial value are extracted. The initialization pattern file generation means generates an initialization pattern file from the initial values of the initialization variables extracted by the initialization variable extraction means. 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 unit receives the executable file and the initialization pattern file transmitted from the programmable controller support device. The executable file storage means stores the executable file received by the receiving means. The initialization pattern file storage means stores the initialization pattern file received by the receiving means. The variable value storage means stores values of various variables when the executable file is activated. The mapping means maps the initialization pattern file to a predetermined area of the variable value storage means when the executable file is activated by the activation means. The initialization means initializes a predetermined area of the variable value storage means corresponding to a variable other than the initialization variable initialized with an initial value predetermined by the initialization pattern file with a value of zero.
[0020]
An application program input that receives the input of the source code of the application program in a programmable controller support apparatus that compiles the source code of the input application program to generate an executable file and then supplies the executable program to the programmable controller for execution. Means for compiling the source code of the application program to generate an executable file, and initialization is performed with a preset initial value among variables included in the source code of the application program. An initializing variable extracted from the initializing variable by the initializing variable extracting means for discriminating the initializing variable from other variables initialized by the value 0 and extracting only the initializing variable and its initial value; An initialization pattern file generating means for generating an initialization pattern file from initial values of variables, an executable file generated by the compiling means, and an initialization pattern file generated by the initialization pattern file generating means There is provided a programmable controller support apparatus comprising: a transmission unit that transmits to a programmable controller; and an activation unit that starts an executable file transmitted by the transmission unit.
[0021]
Here, the application program input means receives the input of the 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 extraction means discriminates among the variables included in the source code of the application program from the initialization variable initialized by a preset initial value and other variables initialized by the value 0 Only the initialization variable and its initial value are extracted. The initialization pattern file generation means generates an initialization pattern file from the initial values of the initialization variables extracted by the initialization variable extraction means. 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.
[0022]
Furthermore, in the programmable controller that the programmable controller support device inputs and executes the executable file generated by compiling the source code of the application program, the executable file transmitted from the programmable controller support device and the initialization pattern Receiving means for receiving a file, executable file storage means for storing the executable file received by the receiving means, and initialization pattern file storage for storing the initialization pattern file received by the receiving means Means, variable value storage means for storing values of various variables when the executable file is activated, and the initialization pattern file when the executable file is activated by the activation means. Above Mapping means for mapping to a predetermined area of the numerical value storage means, and a predetermined area of the variable value storage means corresponding to a variable other than the initialization variable initialized with an initial value predetermined by the initialization pattern file There is provided a programmable controller characterized by having initialization means for initializing the value with a value of 0.
[0023]
Here, the receiving unit receives the executable file and the initialization pattern file transmitted from the programmable controller support device. The executable file storage means stores the executable file received by the receiving means. The initialization pattern file storage means stores the initialization pattern file received by the receiving means. The variable value storage means stores values of various variables when the executable file is activated. The mapping means maps the initialization pattern file to a predetermined area of the variable value storage means when the executable file is activated by the activation means. The initialization means initializes a predetermined area of the variable value storage means corresponding to a variable other than the initialization variable initialized with an initial value predetermined by the initialization pattern file with a value of zero.
[0024]
DETAILED DESCRIPTION OF THE INVENTION
Hereinafter, embodiments of the present invention will be described with reference to the drawings.
In FIG. 1, the programmable controller support device 1 compiles an application program, generates an initialization pattern file, and supplies the initialization pattern file to the programmable controller 3 via the bus 2.
[0025]
When the application program is activated, the programmable controller 3 sets initial values of variables described in the application program by the initialization pattern file supplied from the programmable controller support device 1 and then executes the program.
[0026]
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 compile 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, It is comprised by the transmission means 1g and the starting means 1h.
[0027]
The application program input means 1a receives an application program input. The compiling unit 1b compiles the program input from the application program input unit 1a and generates an executable file.
[0028]
The initialization variable extracting unit 1c extracts the initialization variable and the initialization retain variable from the variables included in the source code of the application program, and extracts the initial values thereof.
[0029]
The initialization pattern file generation means 1d generates an initialization pattern file from the initialization variables extracted by the initialization variable extraction means 1c and the initial values of the initialization retain variables.
[0030]
The common initialization pattern file generation means 1e generates a common initialization pattern file by extracting the common initialization pattern when a declaration statement having a common initialization pattern repeatedly appears in the source code of the application program To do.
[0031]
The mapping information generating unit 1f generates mapping information that is referred to when the common initialization pattern file is mapped by the mapping unit 3d described later.
[0032]
The transmission unit 1g includes an executable file generated by the compiling unit 1b, an initialization pattern file generated by the initialization pattern file generation unit 1d, a common initialization pattern file generated by the common initialization pattern file generation unit 1e, And the mapping information produced | generated by the mapping information production | generation means 1f is transmitted to the programmable controller 3. FIG.
[0033]
The activation unit 1h sends a predetermined control signal to the programmable controller 3 to activate the application program.
The programmable controller 3 includes a receiving unit 3a, an executable file storage unit 3b, an initialization pattern file storage unit 3c, a mapping unit 3d, a variable value storage unit 3e, and an initialization unit 3f.
[0034]
The receiving unit 3a receives the executable file, initialization pattern file, common initialization pattern file, and mapping information transmitted from the programmable controller support apparatus 1.
[0035]
The executable file storage 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.
[0036]
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 share the common initialization pattern file. Is mapped to a specific area of the variable value storage means 3e (an area different from the area where the initialization pattern file is mapped).
[0037]
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 unit 3f initializes the normal variable and the retain variable with the value 0.
[0038]
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 compilation is started by the compiling unit 1b, the initialization variable extracting unit 1c refers to the compilation result of the compiling unit 1b, and the initialization variable is extracted from the application program. (And initialization retain variables).
[0039]
The initialization variable extracted by the initialization variable extraction unit 1c is supplied to the initialization pattern file generation unit 1d, where it is converted into an initialization pattern file. In other words, the initialization pattern file generation means 1d generates an initialization pattern file consisting only of initial values of initialization variables and initialization retain variables.
[0040]
The common initialization pattern file generation unit 1e extracts a common initialization pattern that repeatedly appears in the application program and generates a common initialization pattern file. Note that the common initialization pattern appears, for example, when a function or subroutine having only different initial values is repeatedly used in the application program.
[0041]
The mapping information generating unit 1f generates and outputs information necessary for mapping the common initialization pattern file by the mapping unit 3d (information regarding mapping address, number of repetitions of mapping, etc.).
[0042]
The transmission unit 1g includes an executable file of the application program generated by the compiling unit 1b, an initialization pattern file generated by the initialization pattern file generation unit 1d, and a common initialization generated by the common initialization pattern file generation unit 1e. The pattern file and the mapping information generated by the mapping information generating means 1f are transmitted to the programmable controller 3.
[0043]
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.
[0044]
The initialization pattern file storage unit 3c extracts and stores the initialization pattern file, the common initialization pattern file, and the mapping information from the information received by the reception unit 3a.
[0045]
In such a state, when the activation means 1h of the programmable controller support device 1 transmits a control signal for activating the application program, the application program stored in the executable file storage means 3b is activated. .
[0046]
At that time, the mapping unit 3d maps the initialization pattern file stored in the initialization pattern file storage unit 3c to a specific area of the variable value storage unit 3e, and refers to the mapping information to share the common initialization pattern. The file is mapped to a specific area different from the area to which the initialization pattern file of the variable value storage means 3e is mapped.
[0047]
For example, when the mapping information indicates that the common initialization pattern file is repeatedly mapped five times, the mapping unit 3d maps the common initialization pattern file five times continuously from a specific address.
[0048]
The initialization unit 3f writes “0” to the area where the normal variable and the retain variable are stored in the variable value storage unit 3e, and initializes these variables to the value 0.
Then, when the application program stored in the executable file storage unit 3b actually starts operation, the variable value stored in the variable value storage unit 3e is referred to as appropriate, and is controlled through the bus 4. Modules 5-1 to 5-n will be controlled.
[0049]
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 mapped to a specific area of the variable value storage means 3e. Since it did in this way, it becomes unnecessary to transmit all the initial values, As a result, it becomes possible to reduce the capacity | capacitance of the file transmitted to the programmable controller 3 from the programmable controller assistance apparatus 1.
[0050]
Further, a 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 maps the common initialization pattern to the variable value storage means 3e. Therefore, when the same initialization pattern repeatedly appears in the application program, only one common pattern can be transmitted, so that the programmable controller support device 1 can be programmed in the same manner as described above. The capacity of the file transmitted to the controller 3 can be reduced.
[0051]
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, a RAM 20c, and interfaces 20d and 20e, and compiles an application program input from the input device 10 and is included in the application program. An initialization pattern file of the existing variables is generated and transmitted to the programmable controller 30. Moreover, the programmable controller 30 is controlled as needed and an application program is started.
[0052]
The programmable controller 30 includes a CPU 30a, a ROM 30b, a RAM 30c, and interfaces 30d and 30e, and controls the modules 5-1 to 5-n according to an application program transmitted from the programmable controller support device 20.
[0053]
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.
[0054]
The CPU 20a of the programmable controller support device 20 controls each unit of the device and performs predetermined arithmetic processing. The ROM 20b stores basic programs executed by the CPU 20a. When the CPU 20a executes a predetermined process, the RAM 20c temporarily stores data being calculated or a program being executed.
[0055]
The interface 20 d is, for example, a USB (Universal Serial Bus) or a SCSI (Small Computer System Interface), and inputs an application program from the input device 10. The interface 20d is a serial bus such as RS (Recommended Standard) 232C, and transmits application programs and initialization pattern files created in the programmable controller support device 20 to the programmable controller 30 and programmable operation status of the programmable controller 30. The data is transmitted to the controller support device 20.
[0056]
The bus 4 connects the programmable controller 30 and the modules 5-1 to 5-n to each other, and enables data exchange between them.
The modules 5-1 to 5-n are devices that directly control a control target, and are configured by, for example, digital input / output, analog input / output, and a communication device.
[0057]
Next, the operation of the above embodiment will be described with reference to FIG.
FIG. 3 is a flowchart for explaining an example of processing executed in the programmable controller support device 20 shown 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 it in a predetermined area of the RAM 20c.
[S2] The CPU 20a determines whether or not a predetermined command is input from the input device 10 and the execution of compilation is instructed. If the execution of compilation is instructed, the process proceeds to step S3. Returns to step S2.
[S3] The CPU 20a executes a compilation process.
[0058]
Note that this compile processing is executed according to a compiler program stored in the RAM 20c, for example.
[S4] The CPU 20a extracts an initialization variable included in the application program.
[0059]
FIG. 4 shows how the initialization variable is 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.
[0060]
In this figure, among the parts surrounded by “VAR” and “END_VAR”, the ones to which the initial values are substituted (variable “BBB” and variable “CCC”) are the initialization variables extracted in step S4. .
[S5] The CPU 20a generates an initialization pattern file corresponding to the initialization variable extracted in step S4.
[0061]
In the example of FIG. 4, an initialization pattern file 41 is generated.
[S6] The CPU 20a extracts an initialization retain variable included in the application program.
[0062]
In this figure, among the parts surrounded by “VAR RETAIN” and “END_VAR”, variables (variable “DDD”, variable “EEE”, and variable “FFF”) to which initial values are substituted are determined in step S6. The initialization retain variable to be extracted.
[0063]
Here, “F_1: funcA” is a statement declaring a function block (details 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.
[0064]
In the example of FIG. 4, an initialization pattern file 42 is generated.
[S8] The CPU 20a extracts a common initialization pattern from the function block and generates a common initialization pattern file.
[0065]
Here, the function block means a function block that, when given input is given, executes prescribed processing according to the input and outputs the obtained result. This is equivalent to, for example, a subroutine or a function.
[0066]
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. As shown in the 16th and subsequent lines, the initial value “123” is assigned to the variable AAA to which the input parameter is assigned (for example, F_1 (AAA: = 123)).
[0067]
For example, the sentence “DDD: = F_1.FFF” is a process of inputting the value of the output parameter “FFF” of the function block “funcA” of the instance name F_1 into the variable DDD.
[0068]
By the way, since the variables used in the function block “funcA” are common regardless of the instance name, when the application program is executed, the user memory area corresponding to these function blocks has a common initial value. The mapping pattern is mapped three times.
[0069]
As described above, when there are identical function blocks having different instance names, the common initialization pattern file 51 (see FIG. 5) is generated by extracting the common initialization pattern in the process of step S8.
[S9] The CPU 20a generates mapping information.
[0070]
In the example of FIG. 5, the common initialization pattern of the function block “funcA” is mapped three times continuously from the address “0000200”.
[S10] The CPU 20a generates attribute information.
[0071]
Here, the attribute information is information indicating in a bit state whether or not a variable (stored in units of words) 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.
[0072]
In the example of FIG. 5, the fifth to sixth lines are “1”, and it can be seen that “0456” and “0567” of the common initialization pattern file are the initial values of the retain variables. These variables correspond to the variable DDD and the variable EEE described in the 10th to 11th 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.
[0073]
Through 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.
[0074]
Next, an example of processing executed in the programmable controller 30 will be described with reference to FIGS.
FIG. 6 is a flowchart for explaining an example of processing executed in 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 activation of the application program is requested from the programmable controller support device 20, and proceeds to step S22 if activation is requested, and returns to step S21 in other cases.
[S22] The CPU 30a determines whether or not warm activation is requested. If warm activation is requested, the process proceeds to step S23, and otherwise (when cold activation is requested), the process proceeds to step S24. move on.
[S23] The CPU 30a executes a warm activation process.
[0075]
Details of this process will be described later with reference to FIG.
[S24] The CPU 30a executes a cold start process.
Details of this process will be described later with reference to FIG.
[0076]
FIG. 7 is a flowchart for explaining the details of the warm activation 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.
[0077]
The normal memory area is an area on the RAM 30c where normal variables are stored.
That is, as shown in FIG. 9, the user memory area of RAM 30c (the area where variable values are stored) is a normal memory area 61 where normal variable values are stored, and an initialization variable value is stored. A memory area 62, a retain memory area 63 in which the value of the retain variable is stored, an initialization retain memory area 64 in which the value of the initialization retain variable is stored, and a free memory area 65 in which the value of the function block variable is stored It is divided into
[S32] The CPU 30a maps the initialization pattern file 41 to the initialization memory area 62.
[0078]
This is shown in FIG. As shown in this example, the initialization pattern file 41 of the initialization variable is mapped to the initialization memory area (area in which the value of the initialization variable is stored) 62 of the user memory area.
[S33] The CPU 30a refers to the mapping information 52 and the attribute information 53 and maps the common initialization pattern file 51 to the free memory area 65.
[0079]
That is, as shown in FIG. 10, the CPU 30a refers to the mapping information 52 and performs common initialization for the area corresponding to the variable (ordinary variable and initialization variable) whose attribute information is “0”. Write the initial value of the pattern file and perform initialization.
[S34] The CPU 30a executes the application program stored in the RAM 30c, and returns (returns) to the processing of FIG.
[0080]
Through the above processing, the application program can be restarted in a state where the previous values of the retain variable and the initialization retain variable (the final value of the variable when started last time) are saved.
[0081]
Next, detailed processing of the cold start processing shown in FIG. 6 will be described with reference to FIG. When the flowchart shown in FIG. 8 is started, 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 maps the initialization pattern file 41 to the initialization memory area 62.
[0082]
That is, as shown in FIG. 11, the CPU 30a maps the initialization pattern file 41 of the initialization variable to the initialization memory area 62 of the user memory area.
[S43] The CPU 30a maps the initialization pattern file 42 to the initialization retain memory area 64.
[0083]
That is, as shown in FIG. 11, the CPU 30a maps the initialization pattern file 42 of the initialization retain variable 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.
[0084]
That is, as shown in FIG. 11, the CPU 30 a refers to the common initialization pattern file 51 in which the initial values of all the variables of the function block are stored in the free memory area 65 of the user memory area with reference to the mapping information 52. Map.
[S45] The CPU 30a executes the application program stored in the RAM 30c, and returns (returns) to the processing of FIG.
[0085]
With the above processing, the application program can be started with all variables initialized.
According to the above embodiment, when the application program is compiled in the programmable controller support device 20, the initialization pattern file of the initialization variable and the initialization retain variable is generated, and the initialization pattern file is generated in the programmable controller 30. The other variables are initialized to the value 0 all at once, so that the capacity of the initialization pattern file and attribute information transmitted from the programmable controller support apparatus 20 to the programmable controller 30 is initialized. Can be reduced.
[0086]
Further, according to the present embodiment, when there are a plurality of function blocks having different instance names in the application program, the common initialization pattern file 51 is generated and the mapping information 52 is generated, Since the programmable controller 30 refers to the mapping information 52 and develops the common initialization pattern file 51 in the free memory area 65, the initialization pattern file transmitted from the programmable controller support device 20 to the programmable controller 30 and The capacity of attribute information can be reduced.
[0087]
Furthermore, according to the present embodiment, when warm activation is executed, the retain variable and the initialization retain variable are not initialized, so that the application program activation mode can be changed according to the purpose. Can do.
[0088]
The above processing functions can be realized by a computer. In this case, the processing contents of the functions that the programmable controller support apparatus should have are described in a program recorded on a computer-readable recording medium. By executing this program on the computer, the above processing is performed by the computer. Realized. Examples of the computer-readable recording medium include a magnetic recording device and a semiconductor memory.
[0089]
When distributing to the market, store the program in a portable recording medium such as a CD-ROM (Compact Disk Read Only Memory) or floppy disk, or store it in a computer storage device connected via a network In addition, it can be transferred to another computer through the network. When executed by a 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]
【The invention's effect】
As described above, in the present invention, when compiling an application program in the programmable controller support device, an initialization pattern file of variables initialized by preset initial values is generated, and the programmable controller initializes these initialization programs. Since the variables are initialized by the pattern file and other variables are initialized to the value 0 at once, the capacity of the initialization pattern file and attribute information transmitted from the programmable controller support apparatus to the programmable controller Can be reduced.
[0091]
Further, according to the present embodiment, when a declaration statement having a common initialization pattern repeatedly appears in an application program, a common initialization pattern file is generated, mapping information is generated, and a programmable controller Since the common initialization pattern file is mapped with reference to the mapping information, it is possible to reduce the capacity of the initialization pattern file and attribute information transmitted from the programmable controller support apparatus to the programmable controller. .
[0092]
Furthermore, according to the present embodiment, when the warm activation is executed, the retain variable is not initialized, so that the activation 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 showing a configuration example of an embodiment of the present invention.
FIG. 3 is a flowchart for explaining an example of processing executed in the programmable controller support device shown in FIG. 2;
4 is a diagram showing an example of an initialization pattern file of initialization variables generated by the processing of FIG. 3 and an initialization pattern file of initialization retain variables. FIG.
5 is a diagram showing an example of a common initialization pattern file, mapping information, and attribute information generated by the processing of FIG.
6 is a flowchart for explaining an example of processing executed in the programmable controller shown in FIG. 2;
FIG. 7 is a flowchart illustrating details of a warm start process shown in FIG. 6;
FIG. 8 is a flowchart for explaining the details of the cold start process shown in FIG. 6;
FIG. 9 is a diagram showing a manner of dividing a user memory area on the RAM shown in FIG. 2;
10 is a diagram showing an example of initialization of a user memory area when the process shown in FIG. 7 is executed. FIG.
11 is a diagram showing an example of initialization of a user memory area when the process shown in FIG. 8 is executed. FIG.
FIG. 12 is a diagram illustrating an example of a conventional initialization pattern file and attribute information generation method.
FIG. 13 is a diagram illustrating a state in which an initialization pattern file is mapped to a user memory at a conventional cold start.
FIG. 14 is a diagram illustrating a state in which an initialization pattern file is mapped to a user memory during a conventional warm start.
[Explanation of symbols]
1 Programmable controller support device
1a Application program input means
1b Compile 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 Starting means
2 buses
3 Programmable controller
3a Receiving means
3b Executable file storage means
3c Initialization pattern file storage means
3d mapping means
3e Variable value storage means
3f Initialization means
4 Bus
5-1 to 5-n modules

Claims (7)

In a programmable controller system that compiles a source code of an application program input from a programmable controller support device and generates an executable file, then supplies the programmable controller to the programmable controller and executes it,
The programmable controller support device is
Application program input means for receiving the source code of the application program;
Compiling means for compiling source code of the application program to generate an executable file;
Among the variables included in the source code of the application program, an initialization variable that is initialized with a preset initial value is distinguished from other variables that are initialized with a value of 0, An initialization variable extraction means for extracting only the initial value;
An initialization pattern file generation means for generating an initialization pattern file from an initial value of the initialization variable extracted by the initialization variable extraction means;
Transmitting means for transmitting the executable file generated by the compiling means and the initialization pattern file generated by the initialization pattern file generating means to the programmable controller;
Starting means for starting the executable file transmitted by the transmission means,
The programmable controller is
Receiving means for receiving the executable file transmitted from the programmable controller support device and the initialization pattern file;
Executable file storage means for storing the executable file received by the receiving means;
Initialization pattern file storage means for storing the initialization pattern file received by the receiving means;
Variable value storage means for storing values of various variables when the executable file is activated;
Mapping means for mapping the initialization pattern file to a predetermined area of the variable value storage means when the executable file is activated by the activation means;
Initialization means for initializing a predetermined area of the variable value storage means corresponding to a variable other than the initialization variable initialized with an initial value predetermined by the initialization pattern file with a value of 0;
A programmable controller system comprising: The activation means includes
Among various variable values stored in the variable value storage means, warm activation that restarts the executable file in a state in which the variable value of the retain variable is saved;
Activating the executable file by any one of the cold activations that activate the executable file in a state in which the values of all the variables stored in the variable value storage means are initialized,
The mapping means includes
When the warm start is executed, variable values other than the retain variable are mapped,
2. The programmable controller system according to claim 1, wherein when the cold activation is executed, all of the initialization pattern files are mapped. When a declaration statement having a common initialization pattern repeatedly appears in the source code of the application program, the programmable controller support device extracts the common initialization pattern and generates a common initialization pattern file A common initialization pattern file generation means;
Mapping information generating means for generating mapping information to be referred to when the common initialization pattern file is mapped by the mapping means;
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. The programmable controller support device further includes attribute information generation means for generating attribute information indicating whether each of the variable groups having the initialization pattern generated by the common initialization pattern file generation means is a retain variable. And
The activation means includes
Among various variable values stored in the variable value storage means, warm activation that restarts the executable file in a state in which the variable value of the retain variable is saved;
Activating the executable file by any one of the cold activations that activate the executable file in a state in which the values of all the variables stored in the variable value storage means are initialized,
The mapping means of the programmable controller is
When the warm start is executed, a variable value other than the retain variable is extracted and mapped from the common initialization pattern file with reference to the attribute information,
4. The programmable controller system according to claim 3, wherein when the cold activation is executed, all the common initialization pattern files are mapped with reference to the attribute information. In the programmable controller support device that compiles the source code of the input application program and generates an executable file, and then supplies it to the programmable controller for execution,
Application program input means for receiving the source code of the application program;
Compiling means for compiling source code of the application program to generate an executable file;
Among the variables included in the source code of the application program, an initialization variable that is initialized with a preset initial value is distinguished from other variables that are initialized with a value of 0, An initialization variable extraction means for extracting only the initial value;
An initialization pattern file generation means for generating an initialization pattern file from an initial value of the initialization variable extracted by the initialization variable extraction means;
Transmitting means for transmitting the executable file generated by the compiling means and the initialization pattern file generated by the initialization pattern file generating means to the programmable controller;
Starting means for starting the executable file transmitted by the transmitting means;
A programmable controller support device comprising: In a computer-readable recording medium recording a program for causing a computer to execute a process of supplying an executable file to a programmable controller after compiling an input application program source code to generate an executable file,
The computer,
Application program input means for receiving the source code of the application program;
Compiling means for compiling source code of the application program to generate an executable file,
Among the variables included in the source code of the application program, an initialization variable that is initialized with a preset initial value is distinguished from other variables that are initialized with a value of 0, Initialization variable extraction means for extracting only the initial value,
An initialization pattern file generation means for generating an initialization pattern file from an initial value of the initialization variable extracted by the initialization variable extraction means;
Transmitting means for transmitting the executable file generated by the compiling means and the initialization pattern file generated by the initialization pattern file generating means to the programmable controller;
Starting means for starting the executable file transmitted by the transmitting means;
A computer-readable recording medium storing a program that functions as a computer. In the programmable controller that the programmable controller support device inputs and executes the executable file generated by compiling the source code of the application program,
Receiving means for receiving the executable file transmitted from the programmable controller support device and the initialization pattern file;
Executable file storage means for storing the executable file received by the receiving means;
Initialization pattern file storage means for storing the initialization pattern file received by the receiving means;
Variable value storage means for storing values of various variables when the executable file is activated;
Mapping means for mapping the initialization pattern file to a predetermined area of the variable value storage means when the executable file is activated by the activation means;
Initialization means for initializing a predetermined area of the variable value storage means corresponding to a variable other than the initialization variable initialized with an initial value predetermined by the initialization pattern file with a value of 0;
A programmable controller comprising:

Images