JP2016151973A - Management control system, development support device therefor, and management device - Google Patents

Abstract

PROBLEM TO BE SOLVED: To update a program of a PLC by generating only a machine language object corresponding to an alteration place.SOLUTION: When a source code 21 is a correction version, a front-end compiler 13 converts only a correction place (correction circuit) into an intermediate language 22, and a back-end compiler 14 converts it into a machine language object 24 and also generates an alteration information management table 23 based upon a circuit position table 25, etc. Then the machine language object 24 of the correction version is transferred to the PLC 30 together with the alteration information management table 23. The PLC 30 updates an existing machine language object 41 using the machine language object 24 of the correction version and the alteration information management table 23.SELECTED DRAWING: Figure 1

Description

  The present invention relates to update processing for a control apparatus program.

  In the PLC software development, “edit source code → compile → transfer to PLC → debug” is repeatedly performed. If there is a defect in the source code during the debugging operation, the source code is corrected and "Compile the corrected version-> Transfer to PLC-> Debug" is executed. In this method, program correction (change / update) of a target such as a PLC is performed online, which is called online update or the like.

  Most of the above work can be dealt with by local correction, but even for some changes, the entire source code file was compiled and transferred. Therefore, it takes time to compile and transfer, and there is a problem that user software development cannot be carried out smoothly.

For example, the prior art of Patent Document 1 is known.
Patent Document 1 discloses a conventional technique in which a source code is first converted into an intermediate code by a front end compiler, and this intermediate code is converted into a machine language object by a back end compiler.

  In the invention of Patent Document 1, the front-end compiler creates a first correspondence table that is correspondence information between source code and intermediate code, and the back-end compiler creates a second correspondence table that is correspondence information between intermediate code and machine language object. When a partial change of the source code occurs, a machine language object of the corresponding part is generated based on the first and second correspondence tables.

  In this way, in the process of repeating a series of operations of coding, compilation, transfer, and debugging in software development of a programmable controller, it is possible to reduce the waiting time of the worker by transferring the machine language object corresponding to the amount of change of the source code. It can be shortened and debugging efficiency can be improved.

JP 2007-188366 A

  Most of the change work during debugging is a local change, but in the conventional method, the entire source code after the change is compiled to generate a machine language object, which is transferred to the target and updated. Most machine language objects were transferred and updated to the target, even though they were the same before and after the change.

  An object of the present invention relates to online update by generating a minimum necessary machine language object formed by compiling only a part including a changed portion, and transmitting the generated object to the target to update the program in the target. It is to provide a control system, a development support device, a control device, etc. that can shorten the time.

  The control control system of the present invention is a control control system having a control device and a development support device that compiles a source code of a program for the control device and converts it into a machine language object, and has the following configuration.

  The development support device converts the source code composed of a plurality of circuits into machine language objects for each circuit and transmits the machine language objects to the control device, and stores the storage location and size information of each machine language object in the circuit location Compile means for registering in the table.

The control device stores the transmitted machine language object in a program storage means.
When the source code is a corrected version, the compiling means transmits a corrected version of the machine language object obtained by converting only the corrected circuit into a machine language object, and The size of the corrected machine language object and the storage position and size information of the machine language object before correction obtained from the circuit position table are transmitted to the control device as correction information.

  In this case, based on the correction information, the control device converts the machine language object corresponding to the corrected circuit among the existing machine language objects stored in the program storage unit to the corrected version. Replace with the machine language object.

  According to the control control system of the present invention, its development support device, control device, etc., a minimum necessary machine language object formed by compiling only a part including a changed portion is generated and transmitted to the target. By updating the program on the target, it is possible to reduce the time required for online update.

It is a block diagram of the control control system of this example. It is a specific example of source code. It is a figure which shows the result of having converted the source code of FIG. 2 into the intermediate language. It is a figure which shows the result of having converted a part of intermediate language of FIG. 3 into the machine language object. It is a process flowchart figure of a front end compiler. (A)-(c) is a figure (the 1) which shows the production | generation process of a circuit position table | surface. It is a process flowchart figure of a back end compiler. (A)-(b) is a figure (the 2) which shows the production | generation process of a circuit position table | surface. It is a figure which shows the mutual relationship of the produced | generated intermediate language and a machine language object. It is a figure which shows the specific example of the source code after a change. It is a flowchart figure (1/2) of a compilation process in case the source code of a process target is an update version. It is a flowchart (2/2) of the compilation process in case the source code of a process target is an update version. (A) is a specific example of the intermediate language before and after the update, and (b) is a specific example of the circuit position table after the update. It is a specific example of a change information management table. It is a figure (1/3) which shows the specific example of the process by the side of PLC which received download information. It is a figure (2/3) which shows the specific example of the process by the side of PLC which received download information. It is a figure (3/3) which shows the specific example of the process by the side of PLC which received download information.

Embodiments of the present invention will be described below with reference to the drawings.
FIG. 1 is a configuration diagram of the control system of this example.
This system includes a development support apparatus (loader) 10 and a PLC (programmable controller) 30. In addition, although PLC is shown here as an example of a control apparatus, not only this example but DCS (Distributed Control System) etc. may be sufficient, for example. This system manages programs of control devices such as PLC and DCS.

  The development support apparatus (loader) 10 has an interface function unit 11 (including an editor function) that allows a user to create a source code 21 of an arbitrary PLC program. The interface function unit 11 is a well-known existing function, and is not particularly described here. The PLC program is a control program executed by the PLC 30.

  The development support apparatus (loader) 10 also converts a compiler function unit (a front-end compiler 13 and a back-end compiler 14) that converts the source code 21 created by the user into a machine language object 24 that operates on the target (PLC 30). Have In this case, once converted into the intermediate language 22 (intermediate code), it is converted into the machine language object 24. The intermediate code is an existing code described in, for example, the above-mentioned Patent Document 1, and is not particularly described here.

  First, the front end compiler 13 analyzes the source code 21 and converts it into an intermediate language 22. Subsequently, the back-end compiler 14 converts the intermediate language 22 into a machine language object 24 that operates on the PLC 30. Such a conversion function itself into the intermediate language 22 and the machine language object 24 is a well-known existing function and will not be particularly described here.

  Here, the compiler function units (front-end compiler 13 and back-end compiler 14) of the present example generate the change information management table 23 and the circuit position table 25 shown in the figure along with the conversion processing. This will be described in detail later with reference to a specific example.

  The development support apparatus (loader) 10 includes a communication function unit 12. The communication function unit 12 can perform communication with, for example, the PLC 30 via a communication line (not shown). For example, the machine language object 24 or the like generated by the above compilation process is downloaded to the PLC 30 by the communication function unit 12.

  The PLC 30 can communicate with the development support apparatus (loader) 10 through the communication function unit 31 and receives the machine language object 24 and the like downloaded as described above. The received machine language object 24 is stored as a machine language object 41 in a predetermined storage area such as a memory (not shown). The PLC 30 includes a program execution management function unit 32, and the program execution management function unit 32 executes the machine language object 41 to control, for example, a control target device (not shown).

  The development support apparatus 10 is realized on a general-purpose computer such as a personal computer, and has a general configuration such as a personal computer in terms of hardware. That is, although not shown in particular, it has, for example, a CPU, a storage device such as a hard disk or a memory, and further includes a screen (display) 15 and an input device 16 (keyboard, mouse, etc.) shown in the drawing.

  A predetermined application program is stored in the storage device in advance. When the CPU executes the application program, various function units such as the interface function unit 11, compiler function units (front-end compiler 13 and back-end compiler 14), and communication function unit 12 are realized.

The source code 21, intermediate language 22, change information management table 23, circuit location table 25, machine language object 24, and the like are stored in the storage device.
Similarly, the PLC 30 also includes an arithmetic processor such as a CPU / MPU (not shown), a memory, and the like, and a predetermined application program is stored in the memory in advance. Various functional units such as the communication functional unit 31 and the program execution management functional unit 32 are realized by the arithmetic processor executing this application program. The machine language object 41 is stored in the memory or the like.

  Here, the development support apparatus (loader) 10 does not compile the entire source code 21 when the source code 21 to be compiled is an updated version (such as version upgrade) of any existing source code. Instead, a machine language object 24 is generated by compiling only a part thereof. Such a machine language object 24 is referred to as a machine language object 24 (part). In accordance with this, the change information management table 23 is generated. Then, the machine function object 24 (part) and the change information management table 23 are downloaded to the PLC 30 by the communication function unit 12.

  The PLC 30 that has received the download data performs an operation of replacing a part of the existing machine language object 41 stored in the memory or the like with the machine language object 24 (part) based on the change information management table 23. . Furthermore, the storage position of another part of the existing machine language object 41 is changed. In this way, the machine language object 41 is updated. This reduces the load of the conversion process to the updated machine language object and reduces the data capacity of the generated machine language object 24 (part).

Hereinafter, the processing functions of the development support apparatus (loader) 10 and the PLC (programmable controller) 30 will be described in more detail using specific examples.
First, FIG. 2 shows a specific example of the source code 21.

  As shown in FIG. 2, the PLC program is described with a set of instructions (circuit) as a unit. That is, it is described in units of circuits. For example, in the case of FIG. 2, the programming language is a ladder language, and in the case of a ladder language, a set of instructions starting from the left bus and ending at the right bus is one circuit. The example program shown in FIG. It consists of three circuits.

  A unique identification number (circuit management number) is assigned to each circuit. In the example shown in FIG. 2, circuit management numbers ‘0001’, ‘0002’, and ‘0003’ are assigned to the three circuits. In this example, for example, the editor function of the interface function unit 11 automatically assigns an arbitrary circuit management number to each circuit and manages each circuit by the circuit management number. Not exclusively.

FIG. 3 shows a result (intermediate language 22; intermediate code) obtained by compiling the source code 21 of FIG. 2 with the front-end compiler 13.
As shown in the figure, for example, the circuit with the circuit management number = “0001” in FIG. 2 is converted into the following intermediate code.

LD C001
AND C002
ST C003
The intermediate code is further converted into a machine language object 24 by the back-end compiler 14. Here, as an example, FIG. 4 shows an example in which “LD C001” is converted into the machine language object 24.

  As shown in FIG. 4, for example, the intermediate language “LD C001” in FIG. 3 is converted into four machine language instructions. In this example, if one instruction in the machine language is 4 bytes, the size of the machine language object is 4 × 4 = 16 bytes. The machine language object is a set of machine language instructions that operate on the PLC. A machine language instruction is the smallest unit that can be directly interpreted / executed by a PLC.

  The front-end compiler 13 and the back-end compiler 14 generate the circuit position table 25 along with the conversion process. 5 and 7 show processing flowcharts of the front-end compiler 13 and the back-end compiler 14, and FIGS. 6 and 8 show examples of generation of the circuit position table 25 associated therewith. 6 and 8A show a state in the middle of generation, and FIG. 8B shows a state where the generation of the circuit position table 25 has been completed.

FIG. 5 is a processing flowchart of the front-end compiler 13. FIGS. 6A to 6C show how the circuit position table 25 is generated in accordance with this processing.
The front-end compiler 13 compiles the source code 21 on a circuit basis, and registers data in the circuit position table 25 as shown in FIGS. 6A to 6C.

  In the process of FIG. 5, first, at the start of the process, the circuit position table 25 is in a state where no data is registered, as shown in FIG. 6A, for example. As shown in the figure, the format of the circuit position table 25 is roughly composed of data items of a circuit management number 51, intermediate language information 52, and machine language object information 53. Further, the intermediate language information 52 includes data items of a start instruction position 52a and an end instruction position 52b. The machine language object information 53 includes data items of a start position 53a and a size 53b.

  In the process of FIG. 5, first, the initial position of the processing target position is set for the circuit position table 25 in the state shown in FIG. 6A (step S11). For example, the pointer is set to the first record. Further, an initial value “1” is set at an intermediate instruction start position α which is an arbitrary variable (step S12).

  Then, the circuit management number of the processing target circuit in the source code 21 (the ladder circuit in this example) to be converted is acquired (step S13), but if it cannot be acquired (step S14, NO), Assuming that the process has been completed (step S22), the present process is terminated. Initially, since the processing target is the top circuit in FIG. 2, the circuit management number (= 0001) is acquired, so that the determination in step S14 is YES, and the process proceeds to step S15. It will be.

Note that the processing target circuit is sequentially updated, and after all the circuits are processed, the determination in step S14 is NO.
In the process of step S15, a circuit (a ladder instruction block) corresponding to the circuit management number acquired in step S13 is acquired from the source code 21 and converted into an intermediate code. Initially, since the circuit with the circuit management number = '0001' is converted, the intermediate code obtained as a result is as follows because it has already been described.

LD C001
AND C002
ST C003
As described above, the conversion process itself is an existing function, and is not particularly described here.

  However, if the conversion to the intermediate code fails (step S16, NO), a compile error is displayed and the process is terminated (step S23). If the conversion to the intermediate code is successful (step S16, YES), the process proceeds to step S17.

In step S17, the number of instructions in the intermediate code obtained by the conversion is counted. In the above specific example, the number of instructions = '3'.
Subsequently, the current value of the intermediate instruction start position α is set in the column of the start instruction position 52a of the intermediate language information 52 in the circuit position table 25 (step S18). Initially, as described above, the intermediate instruction start position α has an initial value (= 1), so that “1” is set in the start instruction position 52a.

  Subsequently, “intermediate instruction start position α + number of instructions−1” is calculated, and this calculated value is set in the column of the end instruction position 52b of the intermediate language information 52 (step S19). Here, as described above, since α = 1 and the number of instructions = 3, “1 + 3-1” = 3 is calculated and set in the column of the end instruction position 52b.

With the above processing relating to the first processing target, the contents of the circuit position table 25 are in the state shown in FIG.
Then, the processing target position in the circuit position table 25 is set as the current next position (step S20). Here, since the current record is the first record, the second record is the processing target position next. Further, the value of the intermediate instruction start position α is updated by the following formula (step S21).

α = α + number of instructions Here, as described above, since α = 1 and the number of instructions = 3, the new α is “4”.
In step S21, the circuit management number of the next processing target circuit is further acquired in the source code 21. Then, the process returns to step S14.

  As a result, this time, the circuit with the circuit management number = '0002' is processed, and by the processing of steps S14 to S19, conversion to the intermediate code and the middle of the second record in the circuit position table 25 associated therewith are performed. Registration of the language information 52 is performed.

  Further, this time, the circuit with the circuit management number = '0003' is processed, and the process of steps S14 to S19 is performed to convert to the intermediate code, and the third record of the circuit position table 25 associated therewith is converted. Registration of the intermediate language information 52 is performed.

As a result, the circuit position table 25 is in the state shown in FIG.
Through the above processing, the front-end compiler 13 converts the source code 21 to be processed arbitrarily into an intermediate language to generate, for example, the intermediate language 22 having the contents shown in FIG. Halfway (FIG. 6C) is generated. That is, the machine language object information 53 has not been registered yet, and thus the circuit position table 25 is in an incomplete state. Then, the circuit position table 25 is completed by the processing of FIG. 7 described below.

FIG. 7 is a processing flowchart of the back-end compiler 14.
In the processing of FIG. 7, first, the initial position of the processing target position is set for the circuit position table 25 in the state shown in FIG. 6C (step S31). For example, the pointer is set to the first record. Furthermore, an initial value “0” is set to the machine language object start position β, which is an arbitrary variable (step S32).

  Then, the intermediate language information 52 at the current processing target position (processing target record) is acquired from the circuit position table 25 (step S33). If the intermediate language information 52 cannot be acquired (step S33, NO), this processing is completed. This process is terminated (step S41). On the other hand, when the intermediate language information 52 (start command position 52a, end command position 52b) at the current processing target position (processing target record) is acquired (step S33, YES), the process proceeds to step S34.

  In step S34, a corresponding intermediate code group is acquired from the intermediate language 22 generated by the front-end compiler 13 based on the intermediate language information 52 acquired in step S33, and converted into a machine language object. . Initially, since the start instruction position 52a = '1' and the end instruction position 52b = '3', the intermediate codes in the first to third lines in the intermediate language 22 shown in FIG. Yes, these are acquired and converted into machine language objects. That is, the following intermediate code group is acquired and converted into a machine language object.

LD C001
AND C002
ST C003
If the conversion to the machine language object has failed (step S35, NO), a compile error is displayed (step S42), and this process is terminated.

  When the conversion into the machine language object is successful (step S35, YES), first, the size of the machine language object as the conversion result is calculated (step S36). Here, it is assumed that the LD instruction in the intermediate language is converted into a 16-byte machine language object, the AND instruction is converted into a 16-byte machine language object, and the ST instruction is converted into a 24-byte machine language object. . In this case, in the above specific example, the size of the machine language object = 16 + 16 + 24 = 56.

  Subsequently, the value of the current machine language object start position β is set in the field of the start position 53a of the current process target position (process target record) in the circuit position table 25 (step S37). Here, since β = initial value “0”, “0” is set in the column of the start position 53a. Further, the size obtained by the process of step S36 is set in the column of the size 53b of the current process target position (process target record) in the circuit position table 25 (step S38). Here, “56” is set in the size 53b column.

Thus, the processing related to the first processing target is completed, and the circuit position table 25 is in the state shown in FIG.
Subsequently, the processing target position in the circuit position table 25 is set as the current next position (step S39). Here, since the current record is the first record, the second record is the processing target position next. Further, the value of the machine language object start position β is updated by the following formula (step S40).

β = β + Size Here, as described above, since β = 0 and size = 56, the new value of β is “56”.

Then, the process returns to step S33.
Thus, this time, the intermediate language information 52 (start instruction position 52a, end instruction position 52b) of the second record in the circuit position table 25 is used, and the corresponding intermediate code is converted into the machine language by the processing of steps S33 to S38. At the same time, the machine language object information 53 of the second record in the circuit position table 25 is registered.

  Further, this time, the intermediate language information 52 (start instruction position 52a, end instruction position 52b) of the third record in the circuit position table 25 is used, and the corresponding intermediate code is converted into a machine by the processing in steps S33 to S38. In addition to the conversion to the word object, the machine language object information 53 of the third record of the circuit position table 25 is registered.

As a result, the circuit position table 25 is in the state shown in FIG. That is, the circuit position table 25 is completed.
Thus, the compiling process relating to the newly created source code 21 is completed, and the machine language object 24 and the circuit location table 25 are generated. Then, the generated machine language object 24 is downloaded to the PLC 30. At this time, the change information management table 23 is not generated. Later, when the source code 21 is updated (version upgrade or the like), the change information management table 23 is generated along with the compilation process and downloaded to the PLC 30.

FIG. 9 shows a specific example of the intermediate language 22 and the machine language object 24 generated by the processing described above for the above specific example, and also shows the relationship between them.
FIG. 9 shows an example of memory storage of the machine language object 24 on the PLC 30 side. That is, the machine language object corresponding to the circuit unit of the circuit management number = “0001” is stored in the area of the addresses “0” to “55” illustrated. The machine language object corresponding to the circuit unit of the circuit management number = “0002” is stored in the areas of the addresses “56” to “151” shown in the figure. The machine language object corresponding to the circuit unit of the circuit management number = “0003” is stored in the areas of the addresses “152” to “304” shown in the figure.

  The addresses such as “0”, “55”, “56”, and “151” may be regarded as relative addresses from the beginning of the machine language object storage area in the memory of the PLC 30, for example. . The machine language object storage area is determined in advance.

  Thereafter, it is assumed that the source code 21 is changed (upgraded or the like) at any time. Note that the user edits the source code 21 by an editor function for editing the source code 21, which is one of the functions of the interface function unit 11 of the development support apparatus 10. Support for editing source code by the editor function is a common technique, and is not particularly described here.

FIG. 10 shows a specific example of the source code 21 after the change.
In this example, a modification is made in which the illustrated contact (C014) is added to the circuit of management number = '0002' in the source code 21 shown in FIG.

  FIG. 10 is a display example of the source code 21 after the change, and * is additionally displayed at the display position of the management number “0002”. This indicates that correction has been made to the circuit with the management number = “0002”. The development support apparatus 10 can recognize which circuit has been modified by the existing function (editor function). Thereby, the above * can also be displayed.

  FIG. 11 and FIG. 12 are flowcharts of the compile processing when the source code 21 to be processed is an updated version (such as an upgraded version). 11 and 12 show one processing flowchart divided into two drawings. Therefore, it may be described as FIG. Here, the processing of the front-end compiler 13 and the processing of the back-end compiler 14 are shown without distinction, but as an example, the processing up to step S57 is the processing of the front-end compiler 13, and the step The processing after S59 may be regarded as the processing of the back-end compiler 14.

  Further, as described above, since it is possible to recognize whether or not the source code 21 to be processed is corrected, the processing shown in FIG. 11 is performed when there is any correction, and it is new when there is no correction. As a matter of course, the processes shown in FIGS. 5 and 7 are performed.

  In the processing of FIG. 11 and the like, first, the initial position of the processing target position is set for the circuit position table 25 in the state shown in FIG. 8B (step S51). For example, the pointer is set to the first record. Further, a circuit management number (referred to as a corrected circuit management number) of the circuit that has been corrected is acquired from the editor function (step S52).

  Here, the editor function, for example, saves the source code 21 in an unedited state in another storage area when editing of the arbitrary source code 21 is started. Then, the edited (corrected) source code 21 is checked against the saved source code 21 to detect a mismatch. For example, matching / non-coincidence is determined by matching on a circuit basis. Thus, the circuit management number of the circuit determined to be inconsistent is stored. In step S52, for example, the stored circuit management number is acquired.

  Subsequently, as processing for moving the processing target position (pointer position) to the position of the record corresponding to the circuit management number of the circuit that has been corrected, the processing of steps S53, S54, and S55 shown in the figure is performed. Run. That is, the circuit management number 51 at the current processing target position (pointer position) is acquired (step S53, YES), and it is determined whether or not this is the same as the correction circuit management number (step S54). If they are not the same (step S54, NO), the pointer position is moved to the next record (step S55), and the process returns to step S53. This process is repeated until the determination in step S54 becomes YES. If there is no next record and the circuit management number 51 cannot be acquired (step S53, NO), the process is terminated (step S71).

  If the determination in step S54 is YES, only the circuit with the corrected circuit management number (the circuit that has been corrected) is converted into an intermediate language (step S56). If conversion to the intermediate language is not possible due to some error (step S57, NO), a compile error is displayed (step S58), and this process is terminated.

  If it can be converted into the intermediate language (step S57, YES), the number of instructions in the intermediate language (intermediate code) is counted (step S59). In the case of the example in FIG. 10, the circuit with the modified circuit management number = '2' is converted, so the intermediate language as the conversion result is, for example, as shown on the right side in FIG. The left side of FIG. 13A shows the conversion result of the circuit with the circuit management number before correction = “2” for comparison.

As shown on the right side of FIG. 13A, since the number of instructions in the intermediate code of the conversion result is 6, the number of instructions “6” is obtained in step S59.
Then, from the start instruction position 52a and end instruction position 52b of the record at the current processing target position (pointer position), the number of instructions in the intermediate code corresponding to the circuit before correction is calculated by the following equation (step S60). .

Number of instructions = end instruction position 52b−start instruction position 52a + 1
In the case of the example in FIG. 8B, the pointer position is the second record, so that the number of instructions = 8−4 + 1 = 5.

  Then, the intermediate code obtained in step S56 is converted into a machine language object (step S61). However, if conversion is not possible due to some error (step S61, NO), a compile error is displayed (step S62) and the process is terminated.

  When the machine language object can be converted (step S61, YES), first, the size of the machine language object is calculated (step S63). The calculation method is the same as in step S36, and in the example shown on the right side of FIG. Based on this size calculation value ('112') and the size 53b of the record at the current processing target position (pointer position), the difference in size before and after the change related to the machine language object is calculated as follows. (Step S64).

Machine language size difference = size calculation value−size 53b
In the case of the above specific example, since the size calculation value = 112 and the size 53b = 96,
Machine language size difference = 112−96 = 16
It becomes. The calculated machine language size difference is retained and used in the process of step S70 described later.

Then, the data is registered in the change information management table 23, and the circuit position table 25 is changed (step S65).
FIG. 14 shows a specific example of the change information management table 23 corresponding to the above specific example.

First, the change information management table 23 includes data items of a circuit management number 61, a start position 62a and size 62b before change 62, and a size 63a after change 63.
In step S65, the modified circuit management number acquired in step S52 is set in the circuit management number 61 field, and the size 53b of the pointer position acquired in step S64 is stored in the size 62b field of 62 before change. The size calculated in step S63 is set in the size 63a column of the changed 63. Furthermore, the start position 53a of the record at the pointer position is acquired, and this is set in the column of the start position 62a before the change 62.

By the above process, the change information management table 23 is in a state where the data shown in FIG. 14 is stored.
Further, in the circuit position table 25, the size 53b at the current pointer position (second record in this example) is changed to the value 63 of the 63 size 63a after the change. Further, “difference in the number of instructions = number of instructions after modification−number of instructions before modification” is obtained from the number of instructions in the intermediate language before and after the correction obtained in steps S59 and S60, and this “difference in the number of instructions” is currently The value of the end instruction position 52b is updated by adding to the value of the end instruction position 52b at the pointer position. In the specific example, since the difference in the number of instructions = 6-5 = 1 and the value of the end instruction position 52b is 8, the value of the end instruction position 52b is updated to “9” (= 8 + 1).

  After that, by executing the processing of steps S66 to S70, other locations in the circuit location table 25 are also changed, thereby completing the change of the circuit location table 25 (step S72). Exit.

  First, the processing target position (pointer position) is moved to the position next to the current position (step S66). In this example, since the pointer position at this time is the second record, it is moved to the third record.

  First, the circuit management number 51 of the record at the current pointer position is acquired (step S67). However, if there is no record data at the pointer position and the circuit management number 51 cannot be obtained (NO in step S67), this process is regarded as completed (step S72) and the process ends.

  When the circuit management number 51 can be acquired (step S67, YES), first, the “difference in the number of instructions” is added to the value of the start instruction position 52a at the current pointer position, so that the start instruction position 52a is obtained. The value is updated (step S68). As described above, in the specific example, “difference in the number of instructions” = 1 and the value of the start instruction position 52a is 9, so the value of the start instruction position 52a is updated to “10” (= 9 + 1).

  Subsequently, the value of the end instruction position 52b is updated by adding the “difference in the number of instructions” to the value of the end instruction position 52b at the current pointer position (step S69). As described above, in the specific example, “difference in the number of instructions” = 1 and the value of the end instruction position 52b is 16, so the value of the end instruction position 52b is updated to ‘17’ (= 16 + 1).

  Further, the value of the start position 53a is updated by adding the machine language size difference obtained in step S64 to the value of the start position 53a at the current pointer position (step S70). In the above specific example, since the machine language size difference = 16 and the value of the start position 53a is 152, 152 + 16 = 168 is set as the start position 53a.

  Then, the process returns to step S66, and the processing target is the next record. However, since there is no fourth record in the above specific example, step S67 is NO, and the process ends. At this time, the circuit position table 25 is in the state shown in FIG. It can be said that the update of the circuit position table 25 is completed.

  Thus, the compilation process related to the updated version (version-up version or the like) is completed, and the compile result is downloaded to the PLC 30. In this case, the download is the change information management table 23 generated above, The machine language object obtained in step S61. In the above specific example, the machine language object obtained in step S61, that is, the machine language object of the circuit that has been corrected, is a machine language object related to the circuit of circuit management number = '2', and the change information management table 23 Is the content shown in FIG.

The processing on the PLC 30 side that has received the download information is shown in FIGS. 15, 16, and 17 using the above specific example.
On the PLC 30 side, the existing machine language object 41 is stored in a predetermined storage area on the memory, for example, as shown on the left side of FIG. The download information is temporarily stored in a temporary storage area (not shown). In this method, a storage area different from the predetermined storage area is prepared on the memory for program update.

  Then, referring to the downloaded change information management table 23, first, the portion of the existing machine language object 41 from the beginning to the immediately preceding machine language object of the circuit that has been corrected is stored in the separate storage area. To copy. This is based on the start position 62a of the change information management table 23, and copies the machine language object in the area from the top of the predetermined storage area to the address “start position 62a-1” to the other storage area. In the illustrated example, only the program stored in the area from the head “0” to the address “55” in the predetermined storage area, that is, the machine language object having the circuit management number 001 is copied to the other storage area. Will be.

  Subsequently, as shown in FIG. 16, the downloaded machine language object (updated machine language object) is stored immediately after the copied machine language object in the other storage area. In a specific example, the updated machine language object with the downloaded circuit management number 002 is stored in the separate storage area in a form that is linked (merged) immediately after the machine language object with the circuit management number 001. For example, the machine language object of the updated version is stored from the address position of the start position 62a (in this example, “56”) in another storage area.

  Finally, the rest of the existing machine language object 41 is copied to another storage area, except that the machine language object of the circuit that has been updated is not copied. In a specific example, it is necessary not to copy the existing machine language object having the circuit management number 002. For this purpose, the start position 62a and the size 62b of the change information management table 23 are used to copy from the address position of “start position 62a + size 62b” to the end in the predetermined storage area to the other storage area. Also in this case, immediately after the updated machine language object having the circuit management number 002 stored, it is concatenated (merged) and stored. For example, the remaining machine language object 41 is stored from the address position of “start position 62a + size 63a” (in this example, “56” + “112” = “168”) in another storage area. Is.

  With the above processing, the update processing of the machine language object 41 on the PLC 30 side is completed. Thereafter, the machine language object in the predetermined storage area may be erased, and the entire machine language object created in the other storage area may be copied to the predetermined storage area. This becomes an updated version of the machine language object 41, and the program execution management function unit 32 executes the updated version of the machine language object 41 to perform control.

The numerical values such as 56, 152, and 168 shown in the figure mean relative addresses from the top in each storage area. Here, it is assumed that the address is in units of 1 byte.
The above description is an example, and the present invention is not limited to this example. For example, the circuit location table 25 may be transmitted to the PLC 30 without generating the change information management table 23. For example, every time the circuit position table 25 is updated, the circuit position table 25 before the update and the circuit position table 25 after the update are transmitted to the PLC 30. Of course, when this method is used, when the circuit position table 25 is updated, it is necessary to temporarily store the circuit position table 25 before update in a save area or the like. In the case of the above example, the circuit position table 25 shown in FIG. 8B and the circuit position table 25 shown in FIG. 13B are transmitted to the PLC 30. On the PLC 30 side, the change point can be detected by comparing the circuit position table 25 received last time with the circuit position table 25 received this time, which is the same information as the change information management table 23.

Note that the change information management table 23 and the circuit position table 25 are collectively referred to as correction information.
The processing on the PLC 30 side as shown in FIGS. 15 to 17 and the like may be executed by the program execution management function unit 32, or other processing function unit (not shown) (for example, a program update unit or the like). ) May be executed.

In addition, it is only an example that the source code is once converted into an intermediate code and then converted into a machine language object, and the target of the present technique is not necessarily limited to this example.
As described above, source code changes / updates work mostly with local changes, but this machine language object has conventionally generated a machine language object by compiling the entire source code of the updated version. Most of the above were generated and transferred to the PLC even though they were the same before and after the change. For this reason, a compile processing load is applied, and a data transfer amount is large.

  On the other hand, with this method described above, it is possible to replace only the changed part in the circuit unit, so that the user's work time and processing load related to the source code change can be reduced, and the user's software can be reduced. This has the effect of improving development efficiency.

  The editor function of the development support apparatus manages source code arbitrarily created by the user for each circuit, and the editor function records the circuit changed by the user. Then, the compiler function unit compiles only the changed circuit to generate a machine language object, further generates the change information management table, and downloads the generated machine language object and the change information management table to the PLC. . The PLC updates the program by merging the received machine language object with the existing machine language object using a change information management table or the like.

10 Development support device (loader)
DESCRIPTION OF SYMBOLS 11 Interface function part 12 Communication function part 13 Front end compiler 14 Back end compiler 21 Source code 22 Intermediate language 23 Change information management table 24 Machine language object 25 Circuit location table 30 PLC
31 Communication function section 32 Program execution management function section 41 Machine language object 51 Circuit management number 52 Intermediate language information 52a Start instruction position 52b End instruction position 53 Machine language object information 53 Open a position 53b Size 61 Circuit management number 62 Before change 62a Start Position 62b Size 63 After change 63a Size

Claims (7)

A control system having a control device and a development support device that compiles a source code of a program for the control device and converts it into a machine language object,
The development support apparatus includes:
Compile means for converting the source code composed of a plurality of circuits into machine language objects for each circuit and transmitting the machine language objects to the control device, and registering the storage location and size information of each machine language object in a circuit location table Have
The control device stores the transmitted machine language object in a program storage means,
When the source code is a modified version, the compiling unit transmits a modified version of the machine language object obtained by converting only the corrected circuit into a machine language object, and the modified version. The machine language object size and the storage position and size information of the machine language object before correction obtained from the circuit position table are transmitted as correction information to the control device,
Based on the correction information, the control device converts a machine language object corresponding to the corrected circuit among the existing machine language objects stored in the program storage means to the machine language of the corrected version. Control and control system characterized by replacement with objects. The controller is
Based on the storage position of the machine language object before correction in the correction information, the machine language object in the area from the beginning of the program storage means to immediately before the storage position is copied to another storage area,
2. The control control system according to claim 1, wherein the machine language object of the modified version is stored immediately after the copying in the different area. The controller is
Based on the storage position and size of the machine language object before modification in the modification information, the remaining existing machine language object stored in the program storage means is immediately after the machine language object of the modified version in the other area. The control control system according to claim 2, wherein the machine language object is updated by copying to the machine control object.   4. The control control system according to claim 1, wherein the compiling unit converts the source code into an intermediate code and then converts the intermediate code into the machine language object. A development support apparatus in a control system having a control apparatus and a development support apparatus that compiles a source code of a program for the control apparatus and converts it into a machine language object,
Compilation that converts the source code composed of a plurality of circuits into machine language objects for each circuit and transmits them to the control device, and registers the storage location and size information of each machine language object in a circuit location table Having means,
When the source code is a modified version, the compiling unit transmits a modified version of the machine language object obtained by converting only the corrected circuit into a machine language object, and the modified version. Development of a control control system, wherein the machine language object size and the storage position and size information of the machine language object before correction obtained from the circuit position table are transmitted as correction information to the control device. Support device. A control device in a control system having a control device and a development support device that compiles a source code of a program for the control device and converts it into a machine language object,
Storing the machine language object transmitted from the development support apparatus in the program storage means;
When a corrected machine language object and correction information are transmitted from the development support apparatus, a corrected portion of each existing machine language object stored in the program storage means is based on the correction information. A control device for a control system, wherein a machine language object corresponding to is replaced with the modified machine language object. Based on the storage position of the machine language object before correction included in the correction information, the machine language object in the area from the beginning of the program storage means to immediately before the storage position is copied to another storage area,
7. The control device for a control system according to claim 6, wherein the machine language object of the modified version is stored immediately after the copying in the different area.