JP6119452B2 - Programmable controller system, its support device, programmable controller, program - Google Patents

Description

  The present invention relates to a system in which a plurality of programmable controllers operate in cooperation via a shared memory, and particularly relates to processing at the time of program update.

  Conventionally, when constructing a system in which a plurality of programmable controllers (hereinafter referred to as PLCs) are operated in cooperation, there is a method of assigning variables to a shared memory and realizing data linkage between PLCs via the shared memory. In general, there are a PLC that writes a value to a shared memory and a PLC that uses (reads) the information. The former is referred to as a writing side PLC, and the latter is referred to as a reading side PLC.

  As is well known, each PLC has a control program for the PLC, and various control target devices are controlled by executing the control program at regular intervals. An arbitrary variable is described in the control program, and a memory area assigned to the variable is accessed when the program is executed. As one type of such a variable, there is a variable that accesses the shared memory as described above, and is referred to as a “common variable” here.

The system as described above can also be said to be a system in which a plurality of PLCs operate in cooperation via a common variable.
Here, in the system as described above, when the control program is updated with respect to the operating PLC, a plurality of PLC programs are updated at the same time. When the program is updated, it is often necessary to update the corresponding control program of the reading PLC.

  Further, conventionally, when a control program is updated, the compiler has a function of taking over an existing allocated memory address for variables of an existing control program. On the other hand, a new variable may be added to the updated version of the control program.

  In such a case, the compiler assigns a new memory area to the new variable. Since this memory area has not been used so far, the stored data is indefinite or a fixed value (generally '0') is stored. It is known that some kind of abnormality may occur when such indefinite data is read.

  Therefore, particularly when there is a new variable related to the “common variable”, the write-side PLC performs at least one write to the allocated memory area to the new variable in the shared memory, and then It is necessary to control the program change so that the reading PLC reads the value. Of course, this is just after the program update. In other words, it is a story when the updated version program is executed for the first time. In other words, the above is to first execute the update program of the write side PLC by executing the update program of the write side PLC at least once to execute the writing of the new variable to the allocated memory area. It needs to be executed.

  However, in the past, it has not been possible to automatically perform such control program change control, and accordingly, the user has issued an instruction manually to determine the program update timing of each PLC.

Alternatively, the control program has been devised to make such work unnecessary. This will be described with reference to FIG.
FIG. 14B shows a control program example of the write side PLC and the read side PLC related to an arbitrary “common variable”. A program example of the PLC 1 shown on the left side of the figure is an example of a control program for the write side PLC. Moreover, the program example of PLC2 shown on the right side of the figure is a control program example of the reading side PLC. In the center of the figure, a storage image of variable data or the like in the shared memory (common memory) is shown.

  In the program example of the PLC 1 shown in the figure, “123” is substituted for variable 1 in the first line. This is an operation on the PLC 1 in which data “123” is written in the memory area allocated to the variable 1 in the common memory. The second line substitutes TRUE for flag 1. As an operation on the PLC 1, this is a process of turning on 1-bit data (flag) in the allocated memory area of the flag 1 in the common memory. That is, when data ‘123’ is written with respect to variable 1, a predetermined flag is turned on. Here, it is assumed that this program is the above-described updated version program, and variable 1 is a “common variable” added by this updated version program.

  On the other hand, the program example of the illustrated PLC 2 is a process of reading data from the allocated memory area of the variable 1 and multiplying by “567” if the flag is ON as a whole. This program is also an updated program.

  As described above, after writing a value in the variable using the flag indicating the validity of the variable value, the flag indicating that the variable value is valid is enabled, and the PLC using the value is When the flag is enabled, program to use the value of the variable.

  As a result, even if the PLC2 update program is executed before the PLC1 update program is executed, the flag ON condition is not satisfied, and the data reading of the variable 1 is not executed. Therefore, the above problem can be prevented. However, with this method, user programming is complicated, and a flag is also required on the common memory. Since the common memory is smaller than the other memory capacity of the PLC, even if it is 1 bit, it is not desired to use an extra area. In this way, there is a problem of wasting extra space for flags.

  FIG. 14B shows a source code example of the control program. Conventionally, a user creates a source code of an arbitrary control program in a support device (not shown). The support apparatus has a compiler, which compiles the source code and converts it into a machine language object that can be executed by the PLC. The compiler assigns an arbitrary memory address to each variable during the compilation process. In addition, the memory allocation result is stored, and when the updated version program is compiled, management is performed so that the same address is allocated to existing variables. Of course, an arbitrary address is newly assigned to a new variable newly added by the updated version program, and it can be said that an unused storage area is assigned.

In some cases, the compiler generates a common variable address table 100 as shown in FIG.
The illustrated common variable address table 100 includes a variable name 101, an address 102, a PLC name 103, and the like. For each variable of the variable name 101, the allocated memory address is stored in the address 102, and information indicating the PLC to be read / written is stored in the PLC name 103 column.

  In the illustrated common variable address table 100, the memory address to be allocated and the PLC to be read / written are registered for each “common variable”. In the figure, “W” means write, and “R” means read. Each PLC name is set in the column of the PLC name 103, and in the illustrated example, the PLC names of PLC1, PLC2, and PLC3 are set. With respect to the variable of the variable name 101, “R” is stored for the PLC name on the reading side, and “W” is stored for the PLC name on the writing side. Therefore, in the example shown in the figure, for variable 1, PLC1 is the writing side, and PLC2 is the reading side.

Also, here, it is assumed that registration regarding the flag is also performed in the common variable address table 100.
Moreover, the prior art currently disclosed by patent document 1 is known.

  In the invention of Patent Document 1, it is possible to create a program using the same label name for the exchange of data between control devices, and the association of the label to the device and the device assignment work are based on the system configuration. Is done automatically. By creating a program using the same label name between the control devices, the device development can be made more efficient.

Japanese Patent No. 4541437

  As described above, with respect to a system in which a plurality of programmable controllers operate in cooperation via a shared memory, conventionally, the above-described problem occurs when updating a control program during system operation. That is, regarding the above “common variable”, there is a possibility that some problem may occur when data is read by the updated version program of the reading side PLC before the data is written by the updated version program of the writing side PLC. . In other words, since the validity of the data of the common variable cannot be guaranteed, the reading side PLC may read indefinite data or the like, which may cause some abnormal operation or the like in the reading side PLC.

  In order to solve this problem, that is, in order to guarantee the validity of the data of the common variable, when using the method described in FIG. 14B, as described above, the user programming is complicated, and the flag This causes problems such as wasting the storage area of the common memory.

Further, the invention of Patent Document 1 does not solve the above problem.
An object of the present invention is to provide a programmable controller capable of guaranteeing the validity of data of a common variable when updating a control program during operation of a PLC without requiring a flag or data validity judgment process. It is to provide a system, a programmable controller, a support device, and the like.

  The programmable controller system of the present invention is a system in which a support device and a plurality of programmable controllers are connected to a network, and realizes data linkage between the plurality of programmable controllers via a common variable, and has the following configuration.

  The support apparatus includes a compiler unit that compiles arbitrary source code that is a source code of a control program for each programmable controller and includes the common variable into a machine language object, and each programmable controller The machine language object for the programmable controller is transferred, and the programmable controller on the reading side of the common variable related to the machine language object to be transferred is notified based on the predetermined information obtained with the compilation process. Based on the transfer / notification means and the predetermined information obtained with the compiling process, the programmable controller on the writing side of the common variable is recognized and the switching instruction is notified to the writing-side programmable controller. Switch instruction means That.

  The programmable controller, in accordance with an arbitrary switching instruction, switching means for switching from the existing machine language object execution state to the transferred new machine language object execution state, and after executing the new machine language object at least once Switching control means for notifying the programmable controller on the reading side notified from the transfer / notification means of a switching instruction or for notifying the switching instruction from the support device.

  According to the programmable controller system of the present invention, the programmable controller, the support device, and the like, when updating the control program during the operation of the PLC without the need to determine the validity of the flag or data, the common variable Data validity can be guaranteed.

It is a block diagram of the programmable controller system of this example. It is a figure which shows the general program execution condition in PLC. It is a figure which shows the specific example of source code management table | surface preparation. (A) is a specific example of the source code, and (b) to (d) are specific examples of the common variable management table. It is FIG. (1) for demonstrating operation | movement by the side of PLC at the time of the control program update in operation. FIG. 10 is a diagram (No. 2) for explaining the operation on the PLC side at the time of updating a control program in operation; FIG. 10 is a diagram (No. 3) for explaining the operation on the PLC side at the time of updating the control program in operation; FIG. 10 is a diagram (No. 4) for explaining the operation on the PLC side when the control program is updated during operation; It is a production | generation process flowchart figure of a related table. (A), (b) is a specific example of the related table generation. It is a processing flow of the development support apparatus at the time of control program update. It is a process flowchart figure of each PLC regarding a program update. It is a functional block diagram of the programmable controller system of this example. (A) is a conventional common variable address table, and (b) is a specific example of a conventional source code.

Embodiments of the present invention will be described below with reference to the drawings.
FIG. 1 is a configuration diagram of the programmable controller system of this example.
The programmable controller system of this example is a system in which a plurality of programmable controllers operate in cooperation via a shared memory, as in the conventional system described above. In other words, this is a system in which a plurality of programmable controllers operate in cooperation via a common variable. The control program is updated during operation. In such a system, the above-described problem may occur in the past. Such a problem can be solved by the programmable controller system of this example.

  The programmable controller system of this example has a configuration in which a plurality of PLCs (programmable controllers) 10 and a development support apparatus 20 are connected to a network 9. In the illustrated example, the plurality of PLCs 10 are exemplified by three PLCs of PLC1, PLC2, and PLC3.

  The configuration of the PLC 10 is substantially the same for all three units. In the illustrated example, the PLC 10 includes a management unit 11, a memory (for program) 12, a common memory 13, an execution management table 14, and the like. The execution management table 14 is stored in a data storage memory (not shown) or the like.

  The memory (for program) 12 stores control programs for various controls executed by the PLC 10. By executing this control program by a CPU (not shown), various controls are performed on a control target device (not shown). The control program is updated while the PLC 10 is in operation.

  As will be described later, the source code of the control program is arbitrarily created in the development support apparatus 20 and is compiled to generate a machine language object. The machine language object is downloaded to the PLC 10 and stored in the memory. (For program) 12. That is, the machine language object of the control program is stored in the memory (for program) 12.

  The control program may be updated. In that case, first, the source code of the updated version of the control program is arbitrarily created in the development support apparatus 20, and this is compiled to generate an updated version of the machine language object. This updated version of the machine language object is sent to the PLC 10. It is downloaded and stored in the memory (for program) 12.

  Here, the control program update is basically performed during operation. Thus, for example, during the process of storing the updated machine language object in the memory (for program) 12 or immediately after the storage is completed, the old version machine language object is stored in the memory (for program) 12 and the CPU It is executed regularly. Then, after storing the updated machine language object in the memory (for program) 12, control program switching processing is performed at any time. As a result, the state where the old machine language object is executed is shifted to the state where the updated machine language object is executed.

  The execution management table 14 is used for execution management control of such machine language objects, which will be described later. The execution management table 14 itself and the “machine language object execution management control” itself using the execution management table 14 are existing technologies, and therefore will be briefly described.

  In addition, the programmable controller system of this example is a system in which a plurality of programmable controllers 10 operate in cooperation via a shared memory as described above, and each PLC 10 has a common memory 13 in this example accordingly. The common memory 13 stores data of variables (the common variables) shared by the plurality of PLCs 10. Conventionally, each PLC 10 is controlled so that the same data is stored in all the common memories 13 by broadcasting the data of its own common memory 13.

  For each common variable stored in the common memory 13, there is a PLC 10 that writes data related to the common variable and a PLC 10 that reads this data. As described above, the former is called a writing side PLC and the latter is called a reading side PLC.

  Here, a new common variable may be added in the updated version of the control program. For such a new common variable, the data storage area of the new common variable is allocated to the common memory 13, but in the initial state, the data in this allocation area is in an indefinite state, '0', or the like. . For this reason, if the reading side PLC related to the common variable reads such indefinite data, there is a possibility of malfunction, which is a problem.

  For this reason, first, the write side PLC related to the new common variable needs to be controlled so that the read side PLC related to the common variable operates after at least one operation of writing data to the allocation area. There is. In this method, this is realized automatically. Details will be described later.

  The variables used in the control program are not limited to the common variables stored in the common memory 13, but “variable” means a common variable stored in the common memory 13 unless otherwise specified in the following description. .

  The management unit 11 performs various controls related to the PLC 10 such as execution and update of the control program. Details will be described later. The memory (for program) 12 stores a predetermined application program in addition to the control program. When the CPU (not shown) executes this application program, for example, various processing functions described later of the management unit 11 are realized.

  The development support apparatus 20 has a function of supporting the creation work of the source code of an arbitrary control program by the user. This function itself is an existing function. Therefore, although not shown or described in particular, for example, each source code 1, 2, 3, etc. shown in the figure is arbitrarily created by the user.

  The source code 1 is a source code of a control program for the PLC 1. Source code 2 is a source code of a control program for PLC2. The same applies to the source code 3. In this description, basically, for example, the source code for PLC1 and the machine language object are always preceded by “1”. That is, the number always starts with ‘1’, such as the source code 1, source codes 1-1, 1-2, machine language object 1, machine language object 1-1 described later. Similarly, for the source code and machine language object for PLC2, for example, the number starts with “2”.

  In this description, the source code number and the machine language object number obtained by compiling the same are made the same. For example, a machine language object 1-1 described later is generated by compiling source code 1-1 described later.

  The development support apparatus 20 includes a compiler 21. The compiler 21 compiles the created source code and converts it into a machine language object that operates on the PLC 10. For example, the machine code object 1 is generated by compiling the source code 1. As described above, the machine language object 1 is for the PLC 1. Then, the machine language object generated by the compiler 21 is downloaded to the corresponding PLC 10 by a transfer unit (not shown). For example, the machine language object 1 is downloaded to the PLC 1. In addition, the function itself which converts into the said machine language object is an existing technique.

  Here, the compiler 21 of this example generates / updates the common variable management table 22 and the source code management table 23 shown in the figure in accordance with the above compilation process. The compiler 21 further generates, for example, a machine language object relation table 24 corresponding to each of the PLCs 1, 2, and 3.

  The generated machine language object relation table 24 is transferred to and stored in the corresponding PLC 10. Each PLC 10 issues a switching command to another PLC 10 in some cases based on the machine language object relation table 24 when updating its own control program. Although this will be described in detail later, the updated version program is executed by the reading PLC 10 after being executed at least once by the writing side PLC 10 related to an arbitrary variable. Therefore, the variable data read from the common memory 13 by the reading-side PLC 10 does not become the indefinite data or the like, and can be prevented from malfunctioning.

  In the programmable controller system configured as described above, the development support apparatus 20 records “write side PLC 10” and “read side PLC 10” related to each common variable in the common variable management table 22 as the compilation is performed. The common variable management table 22 is generated. In addition, when the development support apparatus 20 changes the program of the operating PLC 10, the development support apparatus 20 downloads an updated version of the program and the machine language object association table 24 to the PLC 10, and based on the information in the common variable management table 22. Thus, a program update instruction is transmitted only to the “write side PLC 10”. As a result, first, only the “write side PLC 10” performs its own program update. That is, the state is switched to a state in which the updated version program is executed.

  Here, in this method, the development support apparatus 20 does not need to issue a program update instruction to the “reading PLC 10”. That is, after the program-updated “write-side PLC 10” completes execution of the updated control program at least once, for example, the “write-side PLC 10” Issue a program update instruction.

  In this method, the validity of the data of the common variable is ensured by, for example, the above-described method. That is, it is possible to prevent a situation in which the “reading PLC 10” operates abnormally by reading indefinite data as described above. Details will be described later.

Here, FIG. 2 shows a general program execution situation in the PLC.
In general, the PLC executes a control program at a fixed cycle, and the PLC 10 of this example is the same. That is, each PLC 10 executes the control program at a fixed cycle, for example, as shown in FIG. The control target is, for example, various facilities in a factory (not shown). Then, various control processes on the system are performed in a time zone (vacant time) other than when the control program is executed. For example, various processes such as downloading of an updated version program according to the present method, various processes related to switching of the updated version program, and message transmission / reception processes are executed.

  In FIG. 2, various control processes on the system are described as “system”. That is, the illustrated “system” may be considered to mean a band in which various processes other than the control program are executed.

  For example, the management unit 11 executes execution management of a program as shown in FIG. In addition, a programmer who creates a control program usually creates a control program so that execution is completed within a fixed period.

  As described above, in the development support apparatus 20, the user describes arbitrary source code. The compiler 21 converts the source code into a machine language object, and stores information related to the source code and the machine language object in the source code management table 23.

Here, FIG. 3 shows a specific example of creation of the source code management table 23.
In FIG. 3, it is assumed that in the development support apparatus 20, the user arbitrarily creates a source code 1-1 for PLC 1 and a source code 2-1 for PLC 2.

  Thus, for example, the compiler 21 first compiles the source code 1-1 to generate the machine language object 1-1. Further, predetermined information is stored in the source code management table 23 along with the compilation.

Here, the source code management table 23 includes data items of a number 31, a PLC 32, a source code name 33, and a machine language object name 34 as shown in FIG.
The source code name 33 stores identification information (name, ID, etc.) of the compiled source code, and information indicating which PLC the source code is for is stored in the PLC 32. Here, for example, it is assumed that each source code includes information indicating which PLC source code it is. Then, machine language object identification information (name, ID, etc.) obtained by compiling the source code of the source code name 33 is stored in the machine language object name 34.

  The number 31 stores the management number of this control program (source code name 33 and machine language object name 34). Here, the development support apparatus 20 performs management control so that the same “management number” is assigned to a series of control programs. Here, usually, each control program of the PLC is often upgraded at any time after the initial version is created and the PLC is operated and executed. The “series of control programs” refers to these initial versions and upgraded versions. In other words, if an arbitrary management number is assigned to an initial version of an arbitrary control program, then the same management number is assigned to all updated versions of the control program.

  As described above, a “control program” is a source code and a machine language object, and a machine language object generated by compiling an arbitrary source code is assigned the same management number as that of the source code. Is done.

  As described above, regarding the source code 1-1, if the management number '1' is assigned, the number 31 = 1, PLC32 = PLC1, source code name 33 = source code as shown in the figure. 1-1, machine language object name 34 = machine language object 1-1 is stored in the source code management table 23.

  Subsequently, the compiler 21 compiles the source code 2-1 to generate a machine language object 2-1. Accordingly, as shown in the figure, number 31 = 2, PLC 32 = PLC 2, source code name 33 = source code 2-1, machine language object name 34 = machine language object 2-1 are stored in the source code management table 23. Will be remembered. Here, it is assumed that management number = '2' is assigned to the source code 2-1.

  Here, for example, it is assumed that a source code 1-1 'that is an updated version of the source code 1-1 is created later. In this case, as described above, the management number of the updated source code 1-1 is “1”. Accordingly, the compiler 21 compiles the source code 1-1 ′ to generate a machine language object 1-1 ′, and stores the illustrated information in the source code management table 23 accordingly. That is, the number 31 = 1, PLC 32 = PLC1, source code name 33 = source code 1-1, machine language object name 34 = machine language object 1-1 are stored in the source code management table 23.

  The development support apparatus 20 transmits the generated machine language object and its management number to the corresponding PLC 10 using a communication function (not shown). Note that the corresponding PLC is a PLC of the PLC 32.

The development support apparatus 20 also generates the common variable management table 22. This will be described below with reference to a specific example shown in FIG.
Here, FIG. 4A shows a specific example of part of the source code 1-1.2-1.

In the example shown in the drawing, the following description is given regarding the variable 1 and the variable 2 in a part of the source code 1-1. Note that variable 1 and variable 2 are common variables.
Variable 1: = 123;
Variable 2: = variable 1 * 10;
The first line of the above description assigns the value “123” to the variable 1. This is an operation on the PLC 10, which is a process of writing the data “123” in the storage area assigned to the variable 1. . This storage area is a storage area on the common memory 13. Further, the second line is a process of substituting a calculated value obtained by multiplying the value of variable 1 by “123” into variable 2. This is an operation on the PLC 10 that reads data from the storage area assigned to the variable 1 and writes a calculated value obtained by multiplying this data by '123' to the storage area assigned to the variable 2. .

The example of the source code 2-1 shown in FIG. 4 has the following description.
Internal variable: = Variable 1 * 567:
In the above description, a value obtained by multiplying the value of variable 1 by 567 is substituted for the internal variable. For this purpose, it is necessary to first obtain the value of the variable 1, and this is an operation on the PLC 10 that reads data from the storage area assigned to the variable 1.

  As described above, with respect to the variable 1, PLC1 serves as the writing PLC and PLC2 serves as the reading PLC. This is something that can be interpreted by a compiler. In other words, the compiler 21 can assign an arbitrary address to each variable and determine the writing side PLC / reading side PLC as the source code is compiled. Thus, the common variable management table 22 can be created.

  Conventionally, the user manages the assignment of variables to the common memory. Further, conventionally, as shown in FIG. 14B, programming is performed in accordance with determination of validity / invalidity of values of variables allocated to the common memory. For this purpose, the description of the flag and the management shown in FIG. For this reason, an extra area is required for the flag, and it is complicated because it is necessary for the user to program whether the value is valid or invalid.

  On the other hand, in this method, predetermined information is registered in the common variable management table 22 as the compiler 21 compiles arbitrary source code. The state of this registration is shown in FIGS. 4 (b), (c) and (d). The illustrated example corresponds to the example shown in FIG.

  In this example, the common variable management table 22 is in the state shown in FIG. 4B by the registration process accompanying the compilation process of the source code 1-1 in the example of FIG. Thereafter, the common variable management table 22 is in the state shown in FIG. 4C by the registration process accompanying the compilation process of the source code 2-1 in the example of FIG. Subsequent post-processing causes the common variable management table 22 to be in the state shown in FIG. Hereinafter, these will be described.

  4B, 4C, and 4D, the common variable management table 22 includes a program name 41, a transfer destination PLC 42, a variable name 43, a common memory address 44, each PLC name 45, and the like. Consists of data items.

  In the program name 41, identification information (object name, ID, etc.) of the machine language object generated by the compilation process is registered. In the transfer destination PLC 42, identification information (PLC name, ID, etc.) of the transfer destination PLC of this machine language object is registered. For example, in the case of a machine language object for PLC1, the transfer destination PLC is naturally PLC1. The relationship among the source code, the machine language object, and the transfer destination PLC can be understood by referring to the source code management table 23.

  For example, the variable name of each variable in FIG. 4A and the address of the storage area assigned to the variable are registered in the variable name 43 and the common memory address 44. As described above, since the “variable” in the present description is the common variable, an address on the common memory 13 is assigned.

  The column of each PLC name 45 shows the name of each PLC 10 on the network, and for each variable of the variable name 43, “W” shown in the figure is registered for the writing PLC 10. Then, “R” shown in the figure is registered for the reading-side PLC 10.

  In the state shown in FIG. 4B, variables 1 and 2 as variables relating to the source code 1-1 are registered in the variable name 43, and addresses assigned to these variables are registered in the common memory address 44. Is done. In the example shown in the figure, “1000” is assigned to variable 1 and “1002” is assigned to variable 2.

  Furthermore, as described above, it is known that the source code 1-1 is a source code for PLC1, and it can be analyzed when both the variable 1 and the variable 2 are written. Therefore, as shown in FIG. 4B, “W” is registered in the column “PLC1” in each PLC name 45 for both the variable 1 and the variable 2. At this time, since the variable usage status cannot be determined except for the PLC 1, "None" is registered as shown.

  Conventionally, as in the example shown in FIG. 14A, the writing PLC / reading PLC is discriminated and “W” and “R” are registered. That is, this is an existing technology and will not be described in detail.

  Subsequently, when the source code 2-1 is compiled, predetermined information registration is performed, and the common variable management table 22 is in a state shown in FIG. That is, the machine language object 2-1 as a compilation result is registered in the program name 41, and “PLC2” is stored in the transfer destination PLC. Furthermore, in the example shown in FIG. 4A, since there is a read process for variable 1, “R” is registered in the column “PLC2” in each PLC name 45 as shown in FIG. 4C. become.

  Thereafter, by executing predetermined post-processing, the common variable management table 22 is in the state shown in FIG. That is, in the state of FIG. 4C, only one of “W” or “R” is registered for each variable of the variable name 43. For each variable of the variable name 43, it is made clear which PLC 10 the write side PLC and the read side PLC are respectively. That is, as shown in FIG. 4D, both “W” and “R” are described for each variable of the variable name 43.

  The post-process is generally a process of supplementing the data of “None” using, for example, a variable name as a key. For example, the variable 1 is used in the machine language objects 1-1 and 2-1, and is “W” in the PLC 1 and “R” in the PLC 2. Therefore, the registration contents related to the variable 1 are shown in FIG. Update as in d).

  In the post-processing described above, for example, records in which “W” is registered in each PLC name 45 among the records in the common variable management table 22 are sequentially processed, and the variable name 43 of the processing target record is used to set other records. The record is searched to obtain a record (corresponding record) having the same variable name 43.

  When “R” is registered in each PLC name 45 of the corresponding record, both “W” and “R” are registered in the corresponding column in the PLC name 45 for both the process target record and the corresponding record. To the state. For example, for the processing target record, “R” is registered in the column corresponding to the transfer destination PLC 42 of the corresponding record in the PLC name 45. On the other hand, for the corresponding record, for example, “W” is registered in the column corresponding to the transfer destination PLC 42 of the processing target record in the PLC name 45.

  In the above process, for example, in the example shown in FIG. 4C, first, the first record is a process target record, and the variable name 43 is “variable 1”, so the third record is the corresponding record. The transfer destination PLC 42 of the third record is “PLC2”. Thus, “R” is registered in the “PLC2” field in the PLC name 45 of the first record. As a result, the top record becomes the state shown in FIG. Furthermore, since the transfer destination PLC 42 of the first record is “PLC1”, “W” is registered in the “PLC1” column of the PLC name 45 of the third record. As a result, the third record is in the state shown in FIG.

  In the example shown in FIG. 4C, the second record is the processing target record, but no processing is performed because there is no corresponding record. Therefore, the second record remains in the state of FIG. 4C as shown in FIG.

  Hereinafter, with reference to FIG. 5 to FIG. 8, the operation on the PLC 10 side at the time of updating the control program in operation will be described. Here, FIG. 5, FIG. 6, and FIG. 7 are general operations existing in the past, and FIG. 8 is an operation related to this method. Hereinafter, first, FIGS. 5, 6, and 7 will be briefly described.

  First, as described with reference to FIG. 1 above, each PLC 10 holds an execution management table 14. In this example, there are two types of "current" and "hold". That is, there are two types of execution management table 14-1 and execution management table 14-2 shown in FIG. However, one is not fixed to “current” and the other is “held”, but can be switched at any time. Here, the illustrated “program execution management table pointer” (hereinafter sometimes simply referred to as a pointer) is used. In other words, this pointer points to one of the two tables 14-1 and 14-2, and the table pointed to by this pointer at any time means "current" at that time. . Therefore, in the example of FIG. 5, since the pointer points to the execution management table 14-1, the execution management table 14-1 is for "current" in this state.

  Here, as described with reference to FIG. 1, the control program for the PLC (the machine language object) is stored in the memory 12 for each PLC 10. One or more machine language objects are stored in the memory 12, and in the example of FIG. 5, two machine language objects 1-1 and 1-2 are stored. The storage address of each machine language object 1-1.1-2 is registered in the execution management table 14-1.

  In the PLC 10, each time the control program is executed at the above-mentioned regular cycle, the execution management table 14 indicated by the pointer at that time is referred to, and each address registered in the table 14 is used to correspond to the memory 12. Run the region control program.

  Here, as described above, on the development support apparatus 20 side, the user may create a new (first version) control program, or may create an updated version of an existing control program. Although not described one by one, the user creates the source code of the control program. Therefore, it is necessary to compile the created first / updated source code by the compiler 21 and convert it into a machine language object. Then, the generated machine language object is downloaded to the corresponding PLC 10.

  Here, for example, machine language objects 1-1 ′ and 1-2 ′ (not shown) that are updated versions of the existing machine language object 1-1.1-2 are downloaded to the PLC 10 illustrated in FIG. Shall be. In this case, the PLC 10 stores the machine language objects 1-1 ′ and 1-2 ′ (not shown) in the memory 12 and stores the storage addresses in the execution management table 14 for “holding”. That is, in the example of FIG. 5, the storage address is stored in the execution management table 14-2. This will be described below with reference to the examples of FIGS.

  When the received machine language object is stored in the memory 12, the start address of the storage area is stored in the execution management table 14, but the storage position in the table 14 is determined according to the "management number". It may be. That is, the received management number of the machine language object may be used as an index of the execution management table 14 to store the top address of the machine language object corresponding to the position. For example, when the management number is “1”, the top address is arranged at the top of the execution management table 14, and when the management number is “2”, the top address is the second position from the top of the table 14. And so on.

  When a machine language object is executed at a fixed period, first, a machine language object corresponding to the head address or the like stored at the head position of the table 14 is executed, and subsequently stored at the second position. The machine language object corresponding to the head address or the like is executed. However, the present invention is not limited to this example. In this example, the “management number” is also used when determining whether or not it is an updated version, as will be described later, but is not limited to this example.

  In the examples of FIGS. 6 and 7 and FIG. 8 to be described later, one machine language object is used for each PLC 10 for simplicity. That is, here, PLC1 and PLC2 are taken as an example, and PLC1 is operated by machine language object 1-1 (or an updated version thereof), and PLC2 is operated by machine language object 2-1 (or an updated version thereof). And

  For example, at any time, as shown in FIG. 6, in the PLC 1, the machine language object 1-1 is stored in the memory 12, and the storage address is registered in the execution management table 14-1. . In this example, the pointer points to the execution management table 14-1. Therefore, the execution management table 14-1 is for "current". Therefore, in this state, the PLC 1 executes the machine language object 1-1 when executing the control program at a constant cycle.

  In the example of FIG. 6, in the PLC 2, the machine language object 2-1 is stored in the memory 12, and the storage address is registered in the execution management table 14-1. The pointer points to the execution management table 14-1. Therefore, the execution management table 14-1 is for "current". Therefore, in this state, the PLC 2 executes the machine language object 2-1 when executing the control program at a fixed cycle.

  After that, it is assumed that a machine language object 1-1 'that is an updated version of the machine language object 1-1 is generated by the development support apparatus 20 and downloaded to the PLC 1 at any time. Furthermore, in the development support apparatus 20, it is assumed that a machine language object 2-1 'that is an updated version of the machine language object 2-1 is also generated and downloaded to the PLC 2.

  In this case, the PLC 1 additionally stores the machine language object 1-1 ′ in the memory 12, and determines whether the machine language object 1-1 ′ is an updated version of the existing machine language object 1-1. Determine. For example, the “management number” is used. In other words, if the management number of the downloaded control program is the same as the management number of the existing control program stored in the memory 12, it is determined that it is an updated version.

  In the above example, the management number of the machine language object 1-1 and the management number of the machine language object 1-1 'are the same (' 1 '), so that a new machine language object 1- It can be determined that 1 ′ is an updated version of the existing machine language object 1-1. If it is determined that the control program is an updated version of the existing control program, the storage address is registered in the execution management table 14 for “hold” instead of “current”. Therefore, the storage address of the machine language object 1-1 'is registered in the execution management table 14-2 as shown in FIG.

  Similarly, in the PLC 2, the machine language object 2-1 ′ is additionally stored in the memory 12, and the new machine language object 2-1 ′ is an updated version of the existing machine language object 2-1. As shown in FIG. 7, the storage address is registered in the execution management table 14-2 for "holding".

  The above processing results in the state shown in FIG. 7, but the updated version of the program is not yet executed in this state. That is, as shown in FIG. 7, since the “pointer” points to the execution management table 14-1 in both PLC 1 and PLC 2, the existing machine language objects 1-1, 2-1 are regularly executed. Will be executed.

  Here, conventionally, the support device (not shown) or the like thereafter notifies the PLC 1 and PLC 2 of a program update instruction, so that the “pointer” is stored in the execution management table 14-2 in both the PLC 1 and PLC 2. As a result, the execution management table 14-2 becomes “current”.

  Thus, thereafter, the machine language object is executed with reference to the execution management table 14-2 every time the control program having a fixed period is executed. Accordingly, the updated machine language object 1-1 'is executed in the PLC1. Similarly, the updated machine language object 2-1 'is executed in the PLC2. However, in this case, if the machine language object 2-1 'is executed before the machine language object 1-1', a problem may occur. This creates a problem, especially when new variables are added in the updated version. For example, it is assumed that a variable 3 (not shown) is newly added, the writing PLC is PLC1, and the reading PLC is PLC2. If a new address 1004 is assigned to the variable 3, the stored data at the address 1004 is initially in an undefined state. For this reason, when the machine language object 2-1 'is executed first, this indefinite data is read, and there is a possibility that the PLC 2 operates abnormally.

On the other hand, in this method, the occurrence of the above problem can be prevented by performing management control as shown in FIG.
Hereinafter, the operation on the PLC 10 side according to the present technique will be described with reference to FIG. 8, but the operation on the development support apparatus 20 side according to the present technique will be described before that.

  In the development support apparatus 20 according to the present method, for example, the machine language object 1-1 'and the machine language object 2-1' are distributed to the PLC1 and PLC2, respectively, and then the PLC1. Not only the PLC 2 is notified of the program update instruction, but only the writing PLC is notified. The write-side PLC can be determined by referring to the common variable management table 22. That is, in the common variable management table 22, the PLC name 45 that is “W” in the record related to the machine language object to be downloaded is acquired, and this is recognized as the writing PLC.

  In the example shown in FIG. 4D, regarding the machine language object 1-1, both the variable 1 and the variable 2 are “W” with respect to the PLC 1 in the PLC name 45, that is, the PLC 1 is written. It is a nesting side PLC. Although not shown, this setting is inherited also for the machine language object 1-1 ′ which is an updated version, and the variable 3 added as described above has the PLC 1 as the writing side PLC (as it becomes) So that the programmer is supposed to create a control program).

  In the example shown in FIG. 4D, regarding the machine language object 2-1, with respect to the variable 1, “W” is obtained with respect to the PLC 1 in the PLC name 45, that is, the PLC 1 is the writing side PLC. Yes. Although not shown, this setting is inherited for the machine language object 2-1 'which is an updated version, and the variable 1 added as described above has the PLC 1 as the writing side PLC.

  As described above, the machine language objects 1-1 ′ and 2-1 ′ that are downloaded this time, both of which PLC1 is the writing side PLC, the above program update instruction only to PLC1. Will be notified.

  In the above example, the development support apparatus 20 further generates and distributes the machine language object association table 24 corresponding to each of the PLC1 and PLC2. The relation table 24 generation processing is shown in FIG. 9 and will be described later. Here, as the relation table 24 related to the PLC1, the relation PLC 62 related to the machine language object 1-1 ′ is “PLC2” as shown in the figure. It is assumed that 24 is generated and distributed to the PLC 1.

  As described above, the PLC 1 receives the association table 24 having the contents shown in FIG. 8 and also receives a program update instruction. The association table 24 includes a machine language object name 61 and an associated PLC 62 as shown in FIG. With respect to the machine language object having the machine language object name 61, the identification information of the PLC serving as the reading-side PLC is registered in the related PLC 62.

  When the PLC 1 receives the program update instruction, the PLC 1 first switches the execution management table 14 in the same manner as the existing technology, thereby realizing switching of the control program to be executed. That is, the pointer switches from a state indicating the execution management table 14-1 to a state indicating the execution management table 14-2. As a result, after switching, the machine language object 1-1 'is executed at regular intervals.

  Then, when the execution of the machine language object 1-1 'is completed at least once after the switching, the PLC 1 refers to the association table 24 and determines the transmission destination of the switching message. This determines the related PLC 62 corresponding to the new machine language object executed at least once as a transmission destination. Therefore, in this example, “PLC2” that is the related PLC 62 corresponding to the machine language object 1-1 ′ is recognized as a transmission destination, and a switching message is transmitted to the PLC2.

  The PLC 2 that has received the switching message performs substantially the same processing as when the existing program update instruction is received. That is, the execution management table 14 is switched to realize switching of the control program to be executed. That is, the pointer switches from a state indicating the execution management table 14-1 to a state indicating the execution management table 14-2. Thus, after switching, the machine language object 2-1 'is executed at regular intervals. At this time, since the machine language object 1-1 'has been executed at least once as described above, the indefinite data is not read out even for the variable 3.

  The switching message may be the same as the existing program update instruction. In other words, in the above example, the PLC 1 may issue a program update instruction to the PLC 2 instead of the development support apparatus 20. Alternatively, not limited to this example, the PLC 1 may request the development support apparatus 20 to issue a program update instruction to the PLC 2, and the development support apparatus 20 may transmit a program update instruction to the PLC 2 in response thereto.

  FIG. 9 is a flowchart of processing for generating the association table 24 in the development support apparatus 20. This process is executed by a not-shown related table generation function unit. The relation table generation function unit may be included in the compiler 21 or may be a function other than the compiler 21, but is a function that the development support apparatus 20 has anyway.

  The association table 24 is prepared for each PLC as described above. In the above example, the association table 24 for PLC1, the association table 24 for PLC2, and the association table 24 for PLC3 are prepared in advance. ing. However, there is no data in each of the related tables 24 in the initial state, and the data is registered by executing the processes of steps S15 and S16 described later.

After the compiler 21 generates the common variable management table 22 (step S11), the generation process of the association table 24 is started.
First, the common variable management table 22 is read (step S12), and the first processing target is determined (step S13).

  Note that the processing of FIG. 9 basically sets each record as a processing target record sequentially from the first record of the common variable management table 22, and sets the transfer destination PLC 42 as a processing target PLC for each processing target record. And the process of step S14-S17 is performed about a process target record. The first process target record is the first record, and the transfer destination PLC 42 is the process target PLC. In the example of FIG. 4D, PLC1 is the processing target PLC.

  In the processing of steps S14 to S17, first, it is checked whether or not the variable access method of the processing target PLC is “W” (write side) in the processing target record (step S14).

  In the example of FIG. 4D, the first record includes a program name 41 of “machine language object 1-1”, a transfer destination PLC 42 of “PLC1”, a variable name 43 of “variable 1”, and a common memory address 44. Is "1000". Furthermore, in the column of each PLC name 45, PLC1 is “W” and PLC2 is “R”. That is, for the variable 1 of the machine language object 1-1, the transfer destination PLC1 is the writing PLC and the PLC2 is the reading PLC. That is, since the processing target PLC (= PLC1) is “W” (write side), the determination in step S14 is YES, and the process proceeds to step S15.

  In steps S15 and S16, predetermined information based on the processing target record is registered in the association table 24 for the processing target PLC. That is, the program name 41 of the processing target record is stored in the machine language object name 61 of the association table 24 for the processing target PLC (step S15). Further, the reading-side PLC related to the processing target record is stored in the related PLC 62 of the processing target PLC related table 24 (step S16).

  Initially, predetermined information based on the first record is registered in the association table 24 for PLC1. That is, first, the program name 41 (= machine language object 1-1) of the first record is stored in the machine language object name 61 of the association table 24 for PLC1 (step S15). Thus, the association table 24 for PLC 1 is in a state shown in FIG. 10A, for example.

  Subsequently, since the reading-side PLC related to the first record is the PLC 2 as described above, the PLC 2 is registered in the related PLC 62 of the related table 24 for the PLC 1. Thus, the association table 24 for PLC 1 is in a state shown in FIG. 10B, for example.

  Then, the next record is set as a new process target record (step S17), and the process returns to step S14. However, if there is no next record (step S18, NO), this process is terminated. When there is a next record (step S18, YES), the process returns to step S14 as described above.

In addition, when determination of step S14 is NO, it transfers to the process of step S17, without performing the process of step S15, S16.
Here, when the processing related to the first record is completed, the next processing target record is the second record. In the example of FIG. 4D, the second record has a program name 41 of “machine language object 1-1”, a transfer destination PLC 42 of “PLC1”, a variable name 43 of “variable 2”, and a common memory address 44 of The address is “1002”. Furthermore, in each PLC name 45 column, PLC 1 is “W”, but there is no PLC with “R”.

  In this example, the determination in step S14 is YES, so the processing in steps S15 and S16 is performed. However, in step S15, “machine language object 1-1” already exists in the association table 24 for PLC1. Do nothing. Further, in step S16, since there is no writing side PLC as described above, no processing is performed. As a result, the association table 24 for PLC 1 remains in the state shown in FIG.

  Here, in the example of FIG. 4D, if “R” is displayed for the PLC 3 in the column of each PLC name 45 in the second record, the relation table 24 for the PLC 1 is shown in FIG. In the state shown in (b), “PLC3” is further added to the related PLC 62 column. In this example, after switching to the machine language object 1-1 and executing at least once in the PLC 1, the switching message is transmitted to the PLC 2 and the PLC 3.

  Here, when the processing related to the second record is completed, the next processing target record is the third record. In the example of FIG. 4D, the third record has a program name 41 of “machine language object 2-1”, a transfer destination PLC 42 of “PLC2”, a variable name 43 of “variable 1”, and a common memory address 44 of The address is “1000”. Furthermore, in the column of each PLC name 45, PLC1 is “W” and PLC2 is “R”. Therefore, in this example, since the determination in step S14 is NO, no data is registered in the association table 24 for PLC2.

FIG. 11 is a processing flow of the development support apparatus 20 when the control program is updated.
The illustrated process is executed after the development support apparatus 20 completes the generation of the updated machine language object and the generation of the association tables 24 for the PLCs.

  First, the updated machine language object for the PLC is transmitted to each PLC 10 (step S21). As a result, each PLC stores the received updated machine language object in the memory 12 as described above with reference to FIGS. 6 to 8 but does not yet execute it.

  Subsequently, the development support apparatus 20 transmits the association table 24 generated for the PLC to each PLC (step S22). As a result, each PLC stores the received association table 24.

  Then, the development support apparatus 20 transmits the program update instruction to the writing side PLC (step S23). The write-side PLC can be determined by referring to the common variable management table 22. That is, the PLC name 45 where “W” is described is the writing-side PLC. The switch command corresponds to the program update instruction.

  As a result, in the example shown in FIG. 4D, only the PLC 1 is determined to be the writing side PLC, and the program update instruction is transmitted only to the PLC 1. As a result, the PLC 1 performs its own control program update process, for example, as described with reference to FIG. 8, and executes the updated version of the control program at least once. A switching command is transmitted to the program reading PLC. An example of processing for realizing such an operation is shown in FIG.

FIG. 12 is a process flowchart of each PLC related to program update.
In the description of FIG. 12, it is assumed that the program update instruction is the same as the switching command and is unified with the name “switching command”. Therefore, in the following description of FIG. 12, the development support apparatus 20 also transmits a switching command. The PLC 10 that has received the switch command does not need to determine whether the transmission source is the development support apparatus 20 or another PLC 10. In the following description of FIG. 12, it is assumed that there is a case where description is made by using the name of “switching command”.

  In FIG. 12, when the machine language object transmitted in step S21 is received by the development support apparatus 20, it is stored in the memory 12 (step S31). The memory storage process of the received machine language object is as described above. In the case of the updated version, the storage address is registered in the execution management table 14-2 for holding at that time.

When the development support apparatus 20 receives the association table 24 transmitted in step S22, it stores it in a predetermined storage area (step S32).
And it will be in the reception waiting state of a switching command, and if a switching command is received, the process after step S34 will be performed (step S33). In the example of FIG. 8, the PLC 1 receives the switching command from the development support apparatus 20, and the PLC 2 receives the switching command transmitted by the PLC 1.

  When the switching command is received, first, a machine language object switching process is performed (step S34). This is to switch the “pointer” as already described with reference to FIG. This means that the “current” execution management table 14 is switched. If the “pointer” is in a state pointing to, for example, the execution management table 14-1, switching is performed to point to the execution management table 14-2. As a result, the execution management table 14-2 is used for the new “current”. As a result, thereafter, when the control program is executed at regular intervals, the updated version of the machine language object is executed.

  As a result, when the updated version of the machine language object is executed (step S35), the completion of the execution is confirmed (step S36). Then, the switching command is transmitted (step S37). This is to transmit a switching command to the related PLC 62 corresponding to the machine language object name 61 of the executed machine language object in the association table 24. For example, in the case of the example of the association table 24 shown in FIG. 8, the PLC 1 transmits a switching command to the PLC 2 when the execution of the machine language object 1-1 ′ is completed.

  Here, the PLC 2 that has received this switching command also executes the processing of FIG. 12, but in the above example, there is no data in the association table 24 for the PLC 2, so the PLC 2 Switch command is not sent.

  Although not shown, a machine language object 1-2 ′ (not shown) is also downloaded to the PLC 1, and a machine language object name 61 is further added to the “machine language object 1-2” in the association table 24. It is assumed that a record in which the related PLC 62 is “PLC3” is added. In the case of this example, for example, the PLC 1 first transmits a switch command to the PLC 2 when the execution of the machine language object 1-1 ′ is completed, and then further completes the execution of the machine language object 1-2 ′. , A switching command is transmitted to the PLC 3. In this way, it is possible to control the switching instruction for each machine language object.

  As shown in the example shown in FIG. 10, each related PLC 62 is stored in correspondence with each machine language object name 61. As a result, the transmission destination PLC determined in step S37 is a PLC related to the updated machine language object. That is, if the machine language object 1-2 (not shown) is further stored in the PLC 1, but the updated version of the machine language object 1-2 has not been created in this update, the machine language object 1 The switch command is not transmitted to the PLC related to -2.

  Accordingly, the two types of execution management tables 14 of “current” and “hold” and “pointer” may be provided for each machine language object. That is, in this case, the state as shown in FIG. That is, in FIG. 5, the storage addresses of a plurality of machine language objects are registered in one execution management table 14-1, but only one is registered.

  The above description is an example, and the present invention is not limited to this example. For example, only the development support apparatus 20 may transmit the switching command. In this case, instead of the processing in step S37, the development support apparatus 20 is notified of the completion of program update / execution and the PLC as the command transmission destination. In the above example, the PLC 1 notifies the development support apparatus 20 of PLC 2 as a command transmission destination. Accordingly, the development support device 20 may be configured to transmit the switching command to the PLC 2.

Alternatively, in the example of FIG. 8, the switching command is transmitted as a message. However, the present invention is not limited to this example. For example, a method using the common memory 13 may be used.
FIG. 13 is a functional block diagram of the programmable controller system of this example.

The illustrated programmable controller system is a functional block diagram of the development support apparatus 20 and each PLC 10 shown in FIG.
In the illustrated example, the processing functions of the development support apparatus 20 are a compiler unit 71, a transfer / notification unit 72, a switching instruction unit 73, and the like.

  The compiler unit 71 compiles arbitrary source code that is the source code of the control program for each programmable controller and includes the common variable, and converts it into a machine language object.

  As described with reference to FIG. 1, there may be a support processing function for allowing the user to arbitrarily create the source code. However, this function is not indispensable. For example, it is created by any other information processing apparatus or the like. The source code thus obtained may be stored in the development support apparatus 20.

  The transfer / notification unit 72 transfers the machine language object for the programmable controller to each programmable controller and relates to the machine language object to be transferred based on the predetermined information obtained in the compilation process. The programmable controller on the reading side of the common variable is notified. In this case, for example, the machine language object relation table 24 is created and notified.

The predetermined information is, for example, the common variable management table 22 or the like. Alternatively, the source code management table 23 may be provided.
The switching instructing unit 73 recognizes the programmable controller on the writing side of the common variable based on the predetermined information obtained with the compiling process, and notifies the switching instruction to the writing-side programmable controller.

The programmable controller (PLC) 10 includes a switching unit 81, a switching control unit 82, and the like.
The switching unit 81 switches from the existing machine language object execution state to the transferred new machine language object execution state in response to an arbitrary switching instruction.

  After executing the new machine language object at least once, the switching control unit 82 notifies the switching instruction to the reading-side programmable controller notified from the transfer / notification unit. Alternatively, a switching instruction is notified from the support device.

  The switching instruction is, for example, the switching message described above. Basically, as described above, the development support apparatus 20 first notifies the switching message only to the writing side PLC related to an arbitrary common variable, and The writing side PLC related to the common variable transmits a switching message to the reading side PLC after the execution of its own new machine language object is completed. However, as described above, the present invention is not limited to this example.

  As described above, according to the present method, when a program update of a running PLC is performed in a programmable controller system in which a plurality of PLCs operate in cooperation with each other via a common memory, the effectiveness of the common variable is defined as a system. Can be ensured. “Ensuring the validity of a common variable” means that for each common variable, it is guaranteed that the data is always valid when the PLC reading the common variable reads the data. It is. Valid data means that it is not at least indefinite data or uniform “0” data.

  In the past, it was possible to “guarantee the validity of the common variable”. However, as described above, a flag is used or a program for that is separately required for the user. Programming is complicated, human error may occur, and a problem such as wasting the storage area of the common memory due to the flag occurs. In this method, it is possible to “guarantee the effectiveness of common variables” without causing such problems. In other words, there is no user effort, programming is not complicated, there is no risk of human error in programming, no unnecessary flags are required, and the limited shared memory storage area is effectively used. it can.

10 PLC (programmable controller)
11 Manager 12 Memory (for program)
13 common memory 14 execution management table 20 development support device 21 compiler 22 common variable management table 23 source code management table 24 machine language object relation table 31 number 32 PLC
33 Source code name 34 Machine language object name 41 Program name 42 Destination PLC
43 Variable name 44 Common memory address 45 Each PLC name 61 Machine language object name 62 Related PLC

Claims (9)

A support device and a plurality of programmable controllers are connected to a network, and a system for realizing data linkage between a plurality of programmable controllers via a common variable,
The support device includes:
Compiler means for compiling and converting arbitrary source code of the control program for each programmable controller that includes the common variable into a machine language object;
The machine language object for the programmable controller is transferred to each programmable controller, and the common variable related to the machine language object to be transferred is read based on predetermined information obtained in the compilation process. Transfer / notification means for notifying the programmable controller of
Switching instruction means for recognizing the programmable controller on the writing side of the common variable and notifying the switching controller on the writing side based on the predetermined information obtained with the compiling process;
The programmable controller is
A switching means for switching from the existing machine language object execution state to the transferred new machine language object execution state in response to an arbitrary switching instruction;
A switching control means for notifying the programmable controller on the reading side notified from the transfer / notification means of a switching instruction or notifying the switching instruction from the support device after executing the new machine language object at least once. When,
A programmable controller system comprising:   The predetermined information is a common variable management table having information on the programmable controller of the transfer destination, each common variable related thereto, information on the write side and the programmable controller on the read side for each common variable, according to the machine language object. The programmable controller according to claim 1, wherein:   3. The switching from the existing machine language object execution state to the transferred new machine language object execution state by the switching unit is executed during operation of the programmable controller. Programmable controller. The programmable controller is
Machine language object storage means for storing the transferred new machine language object in a storage area different from the existing machine language object;
Address storage means for storing first address information indicating a storage area of the existing machine language object and second address information indicating a storage area of the new machine language object;
Control means for executing a machine language object in a storage area indicated by either the first or second address information at regular intervals;
The programmable controller system according to claim 1, further comprising:   The programmable controller according to claim 1, wherein the new machine language object is a machine language object that is an updated version of the existing machine language object. The support apparatus and the plurality of programmable controllers are connected to a network, and the support apparatus in the system that realizes data linkage between the plurality of programmable controllers via a common variable,
Compiler means for compiling and converting arbitrary source code of the control program for each programmable controller that includes the common variable into a machine language object;
The machine language object for the programmable controller is transferred to each programmable controller, and the common variable related to the machine language object to be transferred is read based on predetermined information obtained in the compilation process. Transfer / notification means for notifying the programmable controller of
Switching instruction means for recognizing the programmable controller on the writing side of the common variable and notifying the switching controller on the writing side based on the predetermined information obtained with the compiling process;
An apparatus for supporting a programmable controller system, comprising: The programmable controller in a system in which a support device and a plurality of programmable controllers are connected to a network and realize data linkage between the plurality of programmable controllers via a common variable,
First storage means for storing an existing machine language object;
Receiving a new machine language object transferred from the support device, second storage means for storing the new machine language object;
Switching means for switching from the existing machine language object execution state to the transferred new machine language object execution state in response to the notified switching instruction;
A switching control means for notifying the programmable controller on the reading side notified from the support device after the execution of the new machine language object at least once, or for notifying the switching instruction from the support device;
A programmable controller system comprising: A computer of the support device in a system in which the support device and a plurality of programmable controllers are connected to a network and realize data linkage between the plurality of programmable controllers via a common variable.
Compiler means for compiling and converting arbitrary source code of the control program for each programmable controller that includes the common variable into a machine language object;
The machine language object for the programmable controller is transferred to each programmable controller, and the common variable related to the machine language object to be transferred is read based on predetermined information obtained in the compilation process. Transfer / notification means for notifying the programmable controller of
A switching instruction means for recognizing the programmable controller on the writing side of the common variable and notifying the switching controller on the writing side based on predetermined information obtained with the compiling process;
Program to function as. A computer of the programmable controller in a system in which a support device and a plurality of programmable controllers are connected to a network and realize data linkage between the plurality of programmable controllers via a common variable.
First storage means for storing an existing machine language object;
Receiving a new machine language object transferred from the support device, second storage means for storing the new machine language object;
Switching means for switching from the existing machine language object execution state to the transferred new machine language object execution state in response to the notified switching instruction;
A switching control means for notifying the programmable controller on the reading side notified from the support device after the execution of the new machine language object at least once, or for notifying the switching instruction from the support device;
Program to function as.

Images