JP6798156B2 - Controller system, its controller, support device - Google Patents

Description

The present invention relates to a programmable controller system.

When debugging in software development, the value of variables may be rewritten to check the program operation. As an example of this, as shown in Patent Document 1, there is a method of rewriting an internal variable and a part of a program. In addition, if some instruments fail during the operation of the plant system and normal values cannot be obtained, the normal operation of the system will be affected. Therefore, the values are temporarily forcibly rewritten to temporarily rewrite the values of the system. It is required to continue operation.

In such a case, the operator needs to rewrite the variable value from the monitoring screen, and after rewriting the variable value, it is necessary to cancel it when the abnormal factor disappears, but the forced setting is canceled and the normal value is canceled. Immediately returning to the system may interfere with the operation of the system in some cases. However, in the prior art, the value is returned to the normal value as soon as the forced setting is canceled.

Normally, the above normal value is written as the value of the above variable. It is written to the storage allocated for the variable. Then, some processing is performed using the stored data in this storage area. When the normal value is, for example, the measured value of an arbitrary sensor, or if the sensor measured value becomes abnormal for some reason, writing this to the storage area causes the processing result to become abnormal. Therefore, in such a case, the stored data in the storage area is forcibly rewritten to a predetermined value (forced setting value).

As described above, if some instruments fail during the operation of the plant system and normal values cannot be obtained, the normal operation of the system will be affected. Therefore, the values are temporarily forcibly rewritten. , It is required to continue the operation of the system.

If some instruments break down during the operation of the plant system and the normal value cannot be captured, this value can be forcibly rewritten. For example, while the system is operating, the measured value of each instrument (sensor, etc.) is input to the controller, and the measured value is stored (data is collected) in the memory area allocated in advance for each instrument. Such a data collection process is executed, for example, at a fixed cycle, so that the stored data of each of the above memory areas is updated at a fixed cycle.

If any instrument fails during operation, an abnormal value will be stored in the memory area of the variable corresponding to the failed instrument, which adversely affects some processing using the value of this memory area. It can occur. By forcibly rewriting the value as described above to avoid this, the system operation can be continued. In this method, for example, a predetermined set value is written in the memory area corresponding to the failed instrument.

However, by continuing the system operation by this, the data collection process at the fixed cycle is also continued, so that the abnormal value is stored again in the memory area corresponding to the failed instrument.

JP-A-2010-122824

Conventionally, when the forcibly rewritten value is returned (when the abnormal state is resolved and the forcible setting is canceled), the value is simply returned to the normal value immediately. For example, the current sensor measurement value is written in the storage area. Since the abnormal condition has been resolved, the normal value should be a normal value, which is not a problem in itself.

However, in some cases, if the difference between the forcibly written value (forced setting value) and the released value (normal value) is large, the operation of the system may be hindered. However, whether or not a problem occurs due to forced cancellation of the system depends on the role of the variable (memory) defined by the user. Therefore, it is difficult to uniformly release the forced setting without causing any trouble in the system.

The subject of the present invention is a controller that can return to a normal value so as not to interfere with the operation of the system by using a correction pattern corresponding to this variable when canceling the forced setting for an arbitrary variable. It is to provide a system, its support device, a controller, and the like.

Controller system of the present invention is a controller system having a support device and a controller, wherein the controller,
-A correction pattern storage means for storing one or more correction patterns and
And correspondence storage means program correspondence between any variable and any of the correction pattern in the are stored,
-When a forced setting is made to forcibly rewrite the value of the variable corresponding to the device when the device to be controlled by the controller is abnormal, the memory address assigned to the variable is normally stored in the memory address. A compulsory setting means that stores the compulsory setting value instead of the value, and
• If the forcing of the said variables are released, along with the execution of the program, when said correspondence relationship storage unit is the correction pattern corresponding to the release target variables the corresponding correction pattern By executing, the forced setting canceling means for gradually approaching the stored value of the memory address of the variable to be canceled from the forced setting value to the normal value, and
Have a, the normal value is a value obtained by a predetermined process relating to the variable by executing the program, the controller is in the normal, storing the normal value in the memory address assigned to the number of the modified It is characterized by doing.

According to the controller system, its support device, the controller, etc. of the present invention, when the forced setting for an arbitrary variable is canceled, in some cases, a correction pattern corresponding to this variable is used so that the operation of the system is not hindered. It can be returned to the normal value as follows.

It is a block diagram of the controller system of this example. This is an example of the system configuration setting screen. (A) and (b) show a specific example of a device-correction pattern correspondence table, and (c) show a specific example of an address-correction pattern correspondence table. It is a figure which shows the specific example of the correction pattern. This is a data configuration example of the forced ON address list. It is a processing flowchart figure at the time of receiving a forced setting command. It is a processing flowchart figure at the time of receiving a command to release a forced setting. It is a flowchart (the 1) which shows the process which concerns on the writing process. It is a flowchart (the 2) which shows the process which concerns on the writing process. This is a specific example of a template (equipment-correction pattern DB).

Hereinafter, embodiments of the present invention will be described with reference to the drawings.
FIG. 1 is a configuration diagram of the controller system of this example.
The controller system of the illustrated example includes a support device 10, a controller 30, and the like.

The support device 10 and the controller 30 are connected to the network 1 and can transmit and receive data to and from each other via the network 1. Further, the controller 30 may be a PLC control device or a DCS (distributed control system) control device.

The support device 10 is a computer device (loader or the like) that provides a program development environment to the user. The support device 10 has various processing functions realized by executing a predetermined application program on a computer. It has, for example, a user interface function for allowing the user to write the source code 13 of an arbitrary program for the controller 30. It also has a compiler function (front-end compiler 11, back-end compiler 12) that converts the source code 13 created by the user into a machine language object 15 that operates on the target. Further, it has a communication function of transmitting the generated machine language object 15 to the target. Since each of these functions is basically an existing general function, the functions other than the compiler function are not shown in particular, and only the above brief explanation is given.

The source code 13 written by the user in the above program development environment is converted into the intermediate code 14 by the front-end compiler 11. The back-end compiler 12 converts the generated intermediate code 14 into a machine language object 15 running on the target. The target is, for example, the controller 30. The file of the machine language object 15 is transmitted to the target by the transmission function (not shown). Further, the "intermediate code" is described in, for example, Japanese Patent Application Laid-Open No. 2013-084112.

Further, the compiler functions (front-end compiler 11 and back-end compiler 12) allocate arbitrary memory addresses to each variable described in the source code 13 in accordance with the conversion process. This is, for example, allocating the address of an arbitrary storage area in the memory 32 of the controller 30, and since this process is also an existing function, it will not be described in detail. Then, the result of address allocation to such a variable is recorded in the variable-address correspondence table 16.

A specific example of the variable-address correspondence table 16 is not particularly shown, but for example, in a table or the like in which the address assigned to the variable is stored in association with the variable name of each variable described in the above source code 13. is there. The variable name may be the name of the above-mentioned instrument or device.

Further, in order to define the configuration of the device to be controlled, the user may arbitrarily define the system configuration and set each device by using the function of the system configuration definition setting unit 22. Since this function itself is an existing function, it will not be described in detail.

As described above, for example, when an arbitrary instrument fails, an abnormal value is stored in the memory area of the variable corresponding to the failed instrument, and therefore the value of this memory area is used. Some processing may be adversely affected. For this reason, the normal operation of the system is affected, so the value of the variable (stored data in the corresponding memory area) is temporarily rewritten to the specified value (forced setting) to operate the system. It is required to continue. However, as described above, a problem may occur when the forced setting is released.

If the developer, etc. determines that a system failure will occur if the forced setting related to a certain variable is simply canceled, the developer, etc. will make corrections to safely cancel the variable in advance. Associate patterns. This correction pattern may be selected and associated with a pre-created correction pattern, or the user may create an original correction pattern and associate it.

The result of associating an arbitrary correction pattern with the above arbitrary variable is reflected in the device-correction pattern correspondence table 24. The device-correction pattern correspondence table 24 is, for example, manually created by the user.

As described above, the support device 10 allocates an arbitrary memory address to the variable by the compile function, and in this method, the correspondence information between the memory address and the correction pattern (address-correction pattern correspondence table 25) is further generated. This is for generating the address-correction pattern correspondence table 25 based on, for example, the device-correction pattern correspondence table 24, but is not limited to this example.

The function of creating the device-correction pattern correspondence table 24 and the process of generating the address-correction pattern correspondence table 25 may be realized, for example, by the above compiler function or by another processing function unit (not shown). May be good. In any case, some functional unit of the support device 10 will be realized. In all of the above-mentioned various processing functions including such a processing function, the arithmetic processor (not shown) of the support device 10 is stored in a storage unit (not shown) regardless of whether it is shown or not shown. It is realized by executing.

Further, the support device 10 may further include a monitoring / instruction function (not shown).
This monitoring / instruction function has a function described below in addition to the existing function of monitoring the state of the controller 30. In addition, the above-mentioned existing monitor function is linked with the abnormality detection function which is an existing function on the controller 30 side, and when there is an abnormality, the abnormality notification function which displays the abnormality location and the corresponding memory address on the screen, and the abnormality notification function It is a recovery notification function that displays on the screen that this abnormality has been resolved and returned to normal. Even if it returns to normal, the corresponding part and the corresponding memory address are also displayed on the screen. Alternatively, not only the above memory address but also the corresponding variable (variable name, etc.) may be displayed. Variable-Address Correspondence The variable name corresponding to the memory address can be found by referring to Table 16.

Further, the monitoring / instruction function of this example also has a processing function of causing the user to perform an arbitrary input operation and transmitting a forced write command and a forced setting release command, which will be described later, to the controller 30 accordingly.

This processing function causes the user to arbitrarily input, for example, an address to be forcibly written and a value (forced setting value) forcibly written to this address. For example, when there is a display by the abnormality notification function, the user inputs the displayed address as the address to be forcibly written. In addition, the forced setting value is arbitrarily determined and input by the user. From this, the support device 10 generates the above-mentioned forced write command including these input addresses and forced setting values and transmits the forced write command to the controller 30.

Further, the processing function causes the user to arbitrarily input an address to be forcibly released, for example. For example, when there is a display by the recovery notification function, the user inputs the displayed address as the address to be forcibly canceled. From this, the support device 10 generates the above-mentioned forced setting release command including the input address and transmits it to the controller 30.

In terms of hardware, the support device 10 is, for example, a general-purpose computer such as a personal computer, and has a hardware configuration such as a general personal computer. Therefore, although not particularly shown, it has, for example, the arithmetic processor such as a CPU, the storage unit such as a hard disk and a memory, a display unit such as a liquid crystal display, an operation unit such as a keyboard and a mouse, and a communication function unit. The predetermined application program is stored in advance in the storage unit.

Similarly, the controller 30 also has an arithmetic processor, a storage unit, and the like (not shown), and a predetermined application program is stored in the storage unit in advance. When the arithmetic processor executes this application program, various functions described later of the controller 30 are realized.

The generated address-correction pattern correspondence table 25 is transferred to the controller 30 and stored as the illustrated address-correction pattern correspondence table 34.
Further, although not shown in the figure, the support device 10 stores the various correction patterns. Then, for example, all the correction patterns registered in the address-correction pattern correspondence table 25 may be transferred to the controller 30 together with the transfer of the correspondence table 25 and stored. From this, the controller 30 also stores the correction pattern.

The correction pattern is a program component (subroutine or the like) as in an example described later. For example, it is compiled, converted into a format that can be executed by the controller 30, and then transferred to the controller 30.

The address-correction pattern correspondence table 25 is automatically generated by, for example, a compiler function based on the variable-address correspondence table 16 and the device-correction pattern correspondence table 24. The device-correction pattern correspondence table 24 is prepared in advance by, for example, a developer or the like. For example, the system configuration information 23 may be used at the time of creation, but the present invention is not limited to this example.

The address-correction pattern correspondence table 25, the device-correction pattern correspondence table 24, and the forced ON address list 35 described later will be described later with specific examples.
Further, the controller 30 holds the forced ON address list 35. When the support device 10 gives the above-mentioned forced write instruction (command) of an arbitrary forced setting value to an arbitrary address, this address and the forced setting value are registered in the forced ON address list 35, and the forced setting is set to the address in the memory 32. Write the value. After that, the state in which the forced setting value is stored is maintained at the address of the memory 32 until the command for canceling the forced setting is received from the support device 10.

Then, when the controller 30 receives the above-mentioned forced setting release command for an arbitrary memory address, the controller 30 refers to the address-correction pattern correspondence table 34 (while also referring / updating the forced ON address list 35), and corresponds to the corresponding memory address. If there is a correction pattern, the processing of this correction pattern is executed, for example, stepwise cancellation is performed. Gradual release means that the stored data of the memory address in which the above forced setting value is stored is not immediately returned from the forced setting value to the normal value, but gradually approaches the normal value from the forced setting value. means.

As described above, the normal value is a value obtained as a result of processing related to an arbitrary variable in the machine language object 33 (for example, a measured value of an arbitrary sensor), and usually corresponds to this variable. A normal value is written to the memory address.

If any problem occurs on the controller 30 side (the device to be controlled, the sensor, etc.), the above normal value becomes an abnormal value, and the abnormal value is written to the corresponding memory address, so that the control operation is performed. Abnormalities may occur. In order to prevent such a situation from occurring, a predetermined value (forced setting value) is forcibly written to the corresponding memory address in such a case, and the state is maintained until the abnormal state is resolved. ..

That is, when any of the above abnormalities occur, the controller 30 registers the memory address and the forced setting value in the forced ON address list 35 when the corresponding memory address and the forced setting value are sent from the support device 10. At the same time, write the forced setting value to this memory address. The controller 30 executes a control program (machine language object 33) at any time, and by this execution, executes various processes including processing such as reading data from the memory 32 and writing data to the memory 32.

Then, every time a data writing process to an arbitrary memory address occurs, it is checked whether or not the writing destination address exists in the "forced ON address list" 35, and if it exists, writing is not performed. By doing so, the memory storage value is forcibly maintained at a predetermined value (the above-mentioned forced setting value). At this time, the value that should be written to the memory (corresponding to the above "normal value"; hereinafter may be referred to as the source value) is stored in the accumulator. As mentioned above, there is a high possibility that the source value is an abnormal value in the abnormal state, but the source value should have returned to the normal value when the forced setting is canceled. However, if the difference between the source value and the forced setting value is large, for example, if the source value is immediately returned to the source value, a problem may occur. From this, in this method, the stored data value of the memory address is determined based on the source value, the forced setting value, etc. by using the correction pattern corresponding to the corresponding memory address (variable corresponding to the corresponding memory address). This determines, for example, the stored data value of the memory address so that it gradually (gradually) approaches the source value from the forced setting value.

The various processes of the controller 30 described above (further described later) may be performed by, for example, the program execution management unit 31, but the present invention is not limited to this example, and some processing function unit (not shown) may perform the various processes. The program execution management unit 31 basically has an existing function of executing a control program (machine language object 33) at a fixed cycle. Then, for example, a process (for example, updating the forced ON address list 35) that occurs with the execution of this control program may be performed. Alternatively, further, processing may be performed according to a command from the support device 10. Further, the processes of FIGS. 6, 7, 8 and 9 described later may be executed by the program execution management unit 31, and not limited to this example, some processing function unit (not shown) performs the processing. You may.

Hereinafter, a specific example will be described in more detail.
The support device 10 also has a function of the system configuration definition setting unit 22 as an existing function, and the user can arbitrarily set the configuration of the device controlled by the controller 30 by using this function. it can. FIG. 2 shows an example of a system configuration setting screen for such a device. In the example of FIG. 2, the device controlled by the controller has a configuration of one servo, one input analog device, and one inverter.

The user gives an arbitrary variable name when creating a program (source code 13), for example. For example, give a variable name to access the information of each device. When the source code 13 is compiled and the machine language object 15 is generated, the compiler function allocates an arbitrary memory address to each variable and registers the allocation result in the variable-address correspondence table 16. Up to this point, the existing technology has been used, but in this method, for example, a developer or the like creates an arbitrary correction pattern in advance, and prepares a device-correction pattern correspondence table 24 accordingly.

First, regarding the correction pattern creation, for example, when the position is controlled by the servo, if the command value is forcibly set, the forced setting is canceled when the difference from the command value calculated by the controller is significant. It may interfere with the operation of the system. Therefore, instead of canceling the forced setting suddenly, a correction pattern for gradually approaching the forced setting value to the source value is created in advance.

It is not always necessary to create a correction pattern for all variables (devices). For example, in the case of a water level sensor, a value is forcibly set when the sensor fails, but after the failure is resolved, it is considered that there is no problem in controlling with the current value immediately, so create a correction pattern. There is no need.

The correction pattern is, for example, a process of gradually approaching the source value from the forced setting value based on the source value and the forced setting value so as not to interfere with the operation of the system when the forced setting is canceled. This process can be selected from a predetermined correction pattern, or a correction pattern programmed by the user can be executed.

The correction pattern can be set by the user as a setting for each device in FIG. 2, or can be set in a list of devices. For example, as an example, the function of the system configuration definition setting unit 22 allows the user to arbitrarily set "device (variable name)", "attribute", "device identification information", etc., and sets a correction pattern related to this device (variable). When set, the device-correction pattern correspondence table 24 is generated. Of course, the present invention is not limited to this example, and for example, a table having the configuration shown in FIGS. 3A and 3B is displayed on the screen, and a user is allowed to input arbitrary data in an arbitrary field in this table. As a result, the device-correction pattern correspondence table 24 may be manually created by the user.

FIGS. 3A and 3B show specific examples of the device-correction pattern correspondence table 24.
In the illustrated example, the device-correction pattern correspondence table 24 includes each data item of the device (variable name) 41, the attribute 42, the device identification information 43, the address 44, and the correction pattern 45.

Among the variables described in the source code 13, all the variables that the user determines that it is necessary to use the correction pattern are registered in the device-correction pattern correspondence table 24. That is, for each of such variables, the variable name is registered in the device (variable name) 41, and at least the identification information (file name, etc.) of the correction pattern associated with the variable is entered in the correction pattern 45 column. It is stored. Further, predetermined information related to the variable (attribute 42, device identification information 43 in the illustrated example) may be further stored, but these may not be described in this description and will not be described in particular.

Further, the field of the address 44 is blank when the user registers (FIG. 3 (a) shows this incomplete state), and then the variable is used when the source code 13 is compiled. The memory address assigned to is automatically stored in the field of address 44 by the compilation function. As a result, the device-correction pattern correspondence table 24 is in a completed state as shown in FIG. 3 (b). Alternatively, the device-correction pattern correspondence table 24 may be brought into the completed state by storing the memory address in the column of the address 44 using the variable-address correspondence table 16 that has already been generated.

A variable-address correspondence table 16 is created in association with the above memory address allocation, and as described above, the allocated memory address for each variable is registered in association with the variable name of each variable. .. The correspondence between this variable and the allocated memory address is included in the device-correction pattern correspondence table 24 as described above, whereas the variables registered in the correspondence table 24 are those in which the correction pattern is associated. Therefore, there is a difference in the correspondence table 16 that basically all variables are registered.

In addition, the memory address allocation process for each variable by the compiler function is an existing process, and the address determination method is not particularly described here.
The support device 10 generates, for example, the address-correction pattern correspondence table 25 from the device-correction pattern correspondence table 24, and transfers this to the controller 30. The controller 30 stores this as the illustrated address-correction pattern correspondence table 34.

FIG. 3C shows a specific example of the address-correction pattern correspondence table 25 (34).
In the illustrated example, the address-correction pattern correspondence table 25 (34) includes each data item of the address 51, the correction pattern 52, and the executing flag 53.

By acquiring the address 44 and the correction pattern 45 from the device-correction pattern correspondence table 24 and storing them in the address 51 and the correction pattern 52, the address-correction pattern correspondence table 25 (34) is generated. The execution flag 53 is set / referenced / updated during the process described later on the controller 30 side, but the execution flag 65 of the forced ON address list 35 may be used instead, so that the execution flag 53 is being executed. Flag 53 is not always necessary. The method of using the executing flag 53 (65) will be described in detail later.

Here, an example in which the user defines the correction pattern will be described.
As described above, the correction pattern may be freely created by the user as desired.
FIG. 4 shows an example of the correction pattern. The correction pattern is a program component to be executed on the controller 30 side.

A specific example of the correction pattern shown in FIG. 4 uses the forced ON address list 35, and it is premised that the forced ON address list 35 has the contents shown in FIG. 5, for example.
From this, before the explanation of the correction pattern of FIG. 4, FIG. 5 will be briefly described.

FIG. 5 is a data configuration example of the forced ON address list 35.
In the example of FIG. 5, the forced ON address list 35 has a control number 61, a forced ON memory address 62, a source value 63, a correction pattern 64, an executing flag 65, a forced setting value 66, an execution number of 67, and a start time 68. Consists of data items. The control number 61 is a serial number or the like attached to each record.

When some abnormality related to an arbitrary memory address occurs, the support device 10 transmits the above-mentioned forced write command (sometimes called a forced setting command) to the controller 30. This forced setting command includes a memory address related to the above abnormality and a forced setting value arbitrarily set by the user on the support device 10 side. These data in the forced setting command are stored in the fields of the forced ON memory address 62 and the forced setting value 66 in the forced ON address list 35. Further, the name of the correction pattern corresponding to the forced ON memory address 62 is acquired from the address-correction pattern correspondence table 34 and stored in the correction pattern 64. If there is no corresponding correction pattern, "none" is stored in the correction pattern 64.

The forced ON address list 35 basically stores predetermined information about the variable for which the forced setting is being executed, and the information of the variable for which the forced setting is completely canceled is deleted from the forced ON address list 35. Will be done. However, in this method, if there is a correction pattern, it may take some time from receiving the release command until the forced setting is completely canceled. During that time, refer to / update the forced ON address list 35. At the same time, the processing at the time of cancellation (FIGS. 8 and 9), which will be described later, is executed. The release command includes, for example, the memory address related to the variable to be released.

In the default state, the start time 68 is "Null", the number of executions 67 is "0", and the execution flag 65 is "FALSE". When the controller 30 receives the forced ON address release command, the controller 30 applies the correction pattern 64 to the corresponding record in the forced ON address list 35 (the record whose forced ON memory address 62 matches the memory address to be released). When the name or the like of the correction pattern is stored, the processing of the correction pattern 64 is started. At that time, the current time is stored in the start time 68, the execution flag 65 is changed from "FALSE" to "TRUE", and the accumulator value is stored in the source value 63.

After that, the process of the correction pattern 64 is repeatedly executed, but if the correction pattern 64 has the contents of FIG. 4, the source value 63, the forced setting value 66, and the number of executions 67 are first executed as arguments after the process is executed. Get the time. The elapsed time is calculated by the current time-start time 68.

Then, the illustrated process is executed using the above arguments. That is, if the number of executions 67 has not yet reached the specified value (= 10), the value of the new setting value is set to "forced setting value 66- (forced setting value 66-source value 63) / (10-number of executions 67). Asked by. In addition, the running flag 65 maintains "TRUE". On the other hand, when the number of executions 67 reaches the specified value (= 10), the value of the newly set value is set as the source value, and the execution flag 65 is returned to "FALSE".

In this way, the illustrated example is an example in which the new set value is brought closer to the source value by 10 divisions, becomes the source value at the 10th time, and the execution of the correction pattern is stopped.
The new setting value is a value stored in the memory address to be released. In the above example, the value stored in the memory address to be released is gradually brought closer to the source value 63 from the forced setting value 66, and finally becomes the source value 63.

The flowcharts of FIGS. 6 to 9 will be described below.
6, FIG. 7, FIG. 8 and FIG. 9 are all processes executed by the controller 30.
FIG. 6 is a processing flowchart when receiving the forced setting command.

As described above, the support device 10 transmits the above-mentioned forced setting command to the controller 30 when there is any abnormality in any variable. In response to this, the controller 30 newly registers the predetermined information in this command in the forced ON address list 35 as described above (step S11). This has already been explained, and to briefly explain here, a new record is added to the forced ON address list 35, and the address and the forced setting value in the command are the forced ON memory address 62 of the new record. It is stored in the column of the forced setting value 66.

Subsequently, the index is set to the initial value (= 1) (step S12), and the processes after step S13 are repeatedly executed while updating the index until step S14 or S15 becomes YES. The index indicates the current processing target record in the address-correction pattern correspondence table 34, and for example, index = 2 indicates the second record in the address-correction pattern correspondence table 34.

First, the address 51 of the record indicated by the current index is acquired from the address-correction pattern correspondence table 34 (step S13), and if this address 51 is NULL (step S14, YES), this process ends. ..

In the correspondence table 34, the address 51 of the next record (last record) of the registered record group is set to NULL. From this, the case where the address 51 is NULL in step S13 is the case where the determination in step S15 has been completed for all the registered records in the correspondence table 34 and all the determination results are NO, that is, the above-mentioned new registration. This is the case when there is no corresponding correction pattern for the variable. Therefore, in this case, the correction pattern 64 of the newly registered record in the forced ON address list 35 becomes "none", and when it is canceled from this, it is immediately returned to the source value.

Further, it is checked whether or not the address 51 acquired in step S13 matches the newly registered address (forced ON memory address 62 of the new record) (step S15), and if they match, the process of step S16 is performed. Execute and end this process.

Here, in this example, the index is initially '1', and the address 51 of the first record of the address-correction pattern correspondence table 34 is first acquired (step S13), and whether or not this matches the newly registered address. Is checked (step S15). If they do not match (steps S15, NO), the index is incremented by +1 to update the processing target, and the process returns to step S13. In the above example, this time, the second address 51 of the address-correction pattern correspondence table 34 is acquired (step S13), and it is checked whether or not this is NULL (step S14). If it is not NULL, the newly registered address is used. It will be checked whether or not they match (step S15).

In this way, it is checked whether or not the newly registered address is registered in the address-correction pattern correspondence table 34, and if it is registered, the process of step S16 is executed. In step S16, the correction pattern 52 (file name, etc.) corresponding to the corresponding address (matching address 51) is stored in the correction pattern 64 column of the record newly added to the forced ON address list 35 in step S11. , The running flag 65 of the record is set to "FALSE".

In this way, every time a forced setting command is received, a new record is added to the forced ON address list 35, and the forced ON memory address 62, the correction pattern 64, the executing flag 65, and the forced setting value 66 of this new record are added. The data is set as described above.

When the user of the support device 10 determines that the abnormality related to the variable for which the forced setting has been made has been resolved, the support device 10 transmits a command for canceling the forced setting to the controller 30 by performing a predetermined operation. This release command contains the memory address of the variable to be released.

Upon receiving the release command, the controller 30 executes the process shown in FIG. 7.
FIG. 7 is a processing flowchart when receiving the forced setting release command.
In the process of FIG. 7, first, the index is set to the initial value (= 1) (step S21), and the processes after step S22 are repeatedly executed while updating the index until step S23 or S24 becomes YES. The index in this processing indicates the current processing target record in the forced ON address list 35.

First, the forced ON memory address 62 of the record indicated by the current index is acquired from the forced ON address list 35 (step S22), and if this address 62 is NULL (step S23, YES), this process ends. To do.

If this address 62 is not NULL (step S23, NO) and matches the address of the release command (step S24, YES), the execution flag 65 of the processing target record in the forced ON address list 35 is set to "TRUE". Set to.

If the address 62 does not match the address of the release command (step S24, NO), the index is incremented by +1 (step S26) and the process returns to step S22. If the address of the release command is not registered in the forced ON address list 35, the determination in step S23 is YES. In the example of FIG. 5, when the processing target becomes the third record, the determination in step S23 is YES.

In the processing example of FIG. 7, when the variable to be released is registered in the forced ON address list 35, the execution flag 65 of the corresponding record is set to “TRUE”. Changing the running flag 65 to "TRUE" means the start of the release process.

The controller 30 repeatedly executes the machine language object 33, for example, at a fixed cycle. Various processes are performed by executing the machine language object 33, and the processes of FIGS. 8 and 9 are executed every time a write process to an arbitrary memory address occurs.

8 and 9 are flowcharts (No. 1) and (No. 2) showing processes related to the writing process, and one process is divided into two drawings. Therefore, FIG. 8 and FIG. 9 are collectively referred to as FIG. 8 and the like without particular distinction.

In the processing of FIG. 8 and the like, first, it is checked whether or not the memory address of the writing destination exists in the forced ON address list 35 (step S31), and if it does not exist (step S31, NO), the writing destination address is forced. Since the setting is not in progress, a normal memory write process is executed (step S32) to end this process. The normal memory write process is a process of storing the normal value in the memory address of the write destination. Normal values are stored in the accumulator.

On the other hand, when the memory address of the write destination exists in the forced ON address list 35 (step S31, YES), the write destination address is being forcibly set. In that case, first, it is checked whether or not the executing flag 65 of the corresponding record in the forced ON address list 35 is “TRUE” (step S33).

Then, when the executing flag 65 is "FALSE" (step S33, NO), this process ends without writing to the memory (step S35). In this case, the write-destination address is being forcibly set and the release has not yet started. At that time, the stored data (normal value) of the current accumulator may be stored in the column of the source value 63 of the corresponding record in the forced ON address list 35 (step S34). The normal writing process is a process of writing the stored data of the current accumulator to the memory address of the writing destination.

The corresponding record is a record whose forced ON memory address 62 matches the memory address of the writing destination.
On the other hand, when the executing flag 65 of the corresponding record is "TRUE" (step S33, YES), first, it is checked whether or not there is a correction pattern in the correction pattern 64 column of the corresponding record (step S36). ), If the correction pattern is “none” (step S36, NO), the corresponding record is deleted from the forced ON address list 35 (step S37), and this process is terminated. From this, when the process of FIG. 8 or the like accompanying the write process to the memory address is executed thereafter, step S31 becomes NO this time, and the normal memory write process is performed. In other words, in this case, a simple forced cancellation as before is performed. At the time of the process of step S37, the above-mentioned normal write process may also be performed.

On the other hand, when the correction pattern is registered in the corresponding record (step S36, YES), the processes of steps S38 to S46 are executed, and if the determination in step S46 is NO, the step S37 is performed. The process is performed and the release process is completed. In other words, until step S46 becomes NO, it can be said that the state is in the middle of the stepwise release process by this method.

First, in step S38, the current time is acquired. Then, when the start time 68 of the corresponding record in the forced ON address list 35 is NULL, that is, when the stepwise release process has not been started yet (steps S39, YES), the current time is stored in the start time 68. (Step S40) Therefore, the stepwise release process is started. On the other hand, when the start time 68 is not NULL (step S39, NO), the elapsed time from the start is obtained by "current time-start time 68" (step S41). The process of step S41 is also performed when step S40 is executed, but of course, in this case, the elapsed time is '0'.

Then, based on the correction pattern 64 (file name, etc.) of the corresponding record, the corresponding correction pattern (the program file, etc.) is acquired (step S42), and the stored data of the current accumulator is used as the source of the corresponding record. The value 63 is overwritten and stored (step S43). The process of step S43 may be executed only at the start of the stepwise release process (when the process of step S40 is performed).

Then, the correction pattern acquired in step S42 is executed (step S44). When the correction pattern is the example of FIG. 4, FIG. 4 takes as arguments the source value 63, the forced setting value 66, the number of executions 67, and the elapsed time obtained in step S41 of the corresponding record in the forced ON address list 35. Execute the process shown in. This process has already been described.

Then, after executing the correction pattern, a predetermined post-processing is executed (step S45). The post-processing includes, for example, updating the number of executions 67 (+1 increment), updating the running flag 65, and the like. Of these, regarding the update of the executing flag 65, in the case of the example of FIG. 4, if the number of executions has not yet reached the specified value (= 10), the current state (= “TRUE”) is maintained and the number of executions is increased. When the specified value is reached, it is set to "FALSE".

From this, "Is the running flag 65" TRUE? "In step S46 following step S45. If the number of executions has not reached the specified value (= 10), the judgment of "" is YES and the process is terminated as it is, and if the number of executions reaches the specified value, it becomes NO and the above. The process of step S37 will be executed. In step S37, as described above, the corresponding record is deleted from the forced ON address list 35, and thus the stepwise release process is completed.

The above-mentioned process is an example, and is not limited to this example. For example, in the above-mentioned example, "execution count" was used to determine the end of processing. That is, when the number of executions 67 reaches the specified value (= 10), the execution flag 65 is set to "FALSE" so that the determination in step S46 becomes NO, but instead of the "number of executions", the above The "elapsed time" may be used. That is, when the elapsed time exceeds the preset predetermined time T (elapsed time> T), the execution flag 65 may be set to "FALSE". Of course, this is also an example, and the present invention is not limited to this example, and for example, some end determination may be made using both the "execution count" and the "elapsed time".

Further, in the above-mentioned example, the correction pattern gradually (stepwise) approaches the normal value of the stored value of the memory address related to the variable to be released from the forced setting value, and finally becomes the normal value. The process is to return, but it is not limited to this example. The correction pattern may be various processes, but at least, by executing the correction pattern, the stored value of the memory address is not immediately returned to the normal value from the forced setting value. The processing of the correction pattern may be any processing as long as it can be returned to the normal value so as not to interfere with the operation of the system.

When the user defines the device configuration information, the correction pattern template may be defined depending on the device. A correction pattern template corresponding to the device is prepared, and the user can arbitrarily define the correction pattern template in the system configuration definition setting unit 22. When setting the device, the correction pattern of the template (device-correction pattern DB21) may be set. The system configuration definition setting unit 22 is a functional unit that allows the user to input arbitrary system configuration information 23, and will not be described in detail. It can be regarded that FIG. 2 shows a specific example of the system configuration information 23, and as described above, the user refers (displays), for example, the system configuration information 23 to create the device-correction pattern correspondence table 24. You may try to do it.

FIG. 10 is a specific example of the above template (equipment-correction pattern DB21).
The template 21 of the illustrated example includes each data item of the device (model) 71, the attribute 72, the offset 73, and the correction pattern 74. The device (model) 71 arbitrarily stores device identification information (for example, model), and the correction pattern identification information (command value, current value, acceleration value, etc.) according to each attribute 72 (command value, current value, acceleration value, etc.) of the arbitrary device 71. (File name, etc.) is registered in the correction pattern 74 column.

Depending on the device, the correction pattern can be determined to some extent in advance, so a DB (database) in which the correction pattern template is registered is prepared for each device. An example of this is the device-correction pattern DB 21.

Information for identifying the device is stored in the device (model) 71. For example, the model number of the device whose correction pattern can be determined in advance, such as the model number of the product, is registered in the device (model) 71. Attribute 72 indicates an attribute possessed by each device. The attributes possessed by each device are different, but the information is fixed for each device.

The offset 73 is relative position information to which the information of the attribute is assigned, and is necessary information when calculating the memory address. For example, when RYT-VE is assigned to% IW1.0, the address will be the address (% IW1.2) obtained by adding the offset from the start address to which the device is assigned.

The correction pattern 74 is as described above.
When a user inserts a device from this device-correction pattern DB 21 (template) by the system configuration function, the device searches the device and sets a template of the corresponding correction pattern. The user can change the correction pattern as needed.

The template 21 is not an essential configuration, and the process using the template 21 is not essential. As described above, the device-correction pattern correspondence table 24 and the method of creating the correction pattern may be various, and the user may manually create the correction pattern from scratch.

Further, from the above, it can be said that the controller system of this example has the following various processing function units, although not particularly shown.
First, the controller 30 has a correction pattern storage unit (not shown), a correspondence storage unit (not shown), a forced setting unit (not shown), a forced setting release unit (not shown), and the like.

The correction pattern storage unit stores one or more of the above correction patterns.
The correspondence storage unit stores the correspondence between any variable in the program and an arbitrary correction pattern. An example of the correspondence storage unit is the address-correction pattern correspondence table 34.

When a compulsory setting is performed for an arbitrary variable, the compulsory setting unit stores the compulsory setting value in the memory address assigned to the variable.
When the forced setting to the variable is canceled, the compulsory setting canceling unit may perform the correction pattern corresponding to the variable to be canceled when the corresponding relation storage means has the correction pattern corresponding to the variable to be released. Execute the correction pattern.

Further, for example, the forced setting release unit does not immediately return the stored value of the memory address from the forced setting value to the normal value by executing the correction pattern. As an example, the forced setting release unit executes a correction pattern to gradually bring the stored value of the memory address closer to the normal value from the forced setting value, and finally returns it to the normal value. .. For example, by doing so, when the forced setting for an arbitrary variable is canceled, the normal value can be returned so as not to interfere with the operation of the system.

Here, the normal value is a value obtained by a predetermined process related to the variable by executing the program, and the controller 30 normally stores the normal value in the memory address assigned to the variable. However, at the time of forced setting, the above forced setting value is stored in the memory address.

Further, for example, in the correspondence stored in the correspondence storage unit, the assigned correction pattern is registered in association with the memory address assigned to the variable for each variable to which an arbitrary correction pattern is assigned. It was done. An example thereof is the address-correction pattern correspondence table 34.

Further, for example, the support device 10 further has a correction pattern management unit (not shown) that arbitrarily creates the correction pattern, transfers the correction pattern to the controller 30, and stores the correction pattern in the correction pattern storage unit. You may.

Alternatively, for example, the support device 10 associates an arbitrary correction pattern with an arbitrary variable (for example, manually performed by the user), and the association result and an arbitrary memory for each variable when compiling the program. It may further have a correspondence management unit (not shown) that generates the correspondence based on the address allocation result, transfers the correspondence to the controller 30, and stores the correspondence in the correspondence storage unit. ..

Further, for example, the support device 10 arbitrarily sets a forced setting value according to an arbitrary variable, and notifies the controller 30 of the memory address of the variable and the forced setting value together with the forced setting instruction. A portion (not shown) may be further provided.

In this case, when the controller 30 performs the forced setting for an arbitrary variable, it is the case where the notification by the first indicating unit is received.
Further, for example, the support device 10 may further have a second instruction unit (not shown) for notifying the controller 30 of a forced setting release command in response to an arbitrary instruction.

In this case, when the forced setting to the variable is canceled in the controller 30, it is the case where the release command is received.
Further, for example, the controller 30 may further have a compulsory setting management information storage unit (not shown) for storing predetermined information regarding the variable being forcibly set. An example thereof is the forced ON address list 35.

In this case, when the compulsory setting unit receives the notification from the first instruction unit, the compulsory setting management information storage unit newly registers the notified memory address and the compulsory setting value.
Further, in this case, the forced setting release unit may delete the corresponding information from the forced setting management information storage unit after returning the stored value of the memory address to the normal value.

The various processing functions of the support device 10 described above are realized by the arithmetic processor (not shown) of the support device 10 executing a predetermined application program stored in the storage unit (not shown). Similarly, the various processing functions of the controller 30 described above are realized by the arithmetic processor (not shown) of the controller 30 executing a predetermined application program stored in the storage unit (not shown).

As described above, in the controller system of this example, the support device 10 puts the source code 13 describing the processing operating on the controller 30 into a form (machine language object 15) that can be executed by the controller 30 by the compiler function. Along with the conversion, the variable-address correspondence table 16 is generated. The variable-address correspondence table 16 has correspondence information between each variable of the source code 13 and the memory address assigned to the variable. The memory address is the address of the memory 32 in the controller 30.

In the support device 10, the user generates association information (device-correction pattern correspondence table 24) between each variable (device) of the source code 13 and the correction pattern when the forced setting is canceled. The address-correction pattern correspondence table 25 is generated from the device-correction pattern correspondence table 24 and the variable-address correspondence table 16 and transmitted to the controller 30.

The correction pattern is a program created in advance, a program arbitrarily described by the user, or the like. For example, the user selects an arbitrary correction pattern from each of these correction patterns for an arbitrary variable and associates it with the arbitrary variable.

Further, by using the template information in which the correction pattern is associated with each device, the correction pattern suitable for the selected device can be associated when the user executes the system configuration definition.

In the controller system of the above example, after the value of the variable is forcibly changed without changing the machine language object while the user's software development work or the system is in operation and the controller 30 is in operation, the variable value is changed. When the state is released, the source value is gradually (gradually) returned while performing the correction pattern.
[Effect of the invention]
For example, when a sensor of a system fails, the value may be forcibly rewritten in order to operate the system stably. This is to forcibly rewrite the stored data of the memory address assigned to the variable corresponding to the failed sensor to a predetermined value (forced setting value).

After that, if the failure is corrected, the above forced setting is canceled, but if the sensor value has a role for the system or there is a discrepancy between the normal value and the forced setting value, simply canceling the forced setting is not enough for the system. May be stable. To simply cancel the forced setting, for example, the stored data of the memory address is immediately changed from the forced setting value to the normal value.

Therefore, for a sensor that can assume such a situation, the above correction pattern is associated with the variable in advance, and when the forced setting is canceled, this correction pattern is used to obtain the value of this variable (memory address). The stored data) is gradually (gradually) approached from the forced setting value to the normal value.

According to this method, since the controller 30 automatically corrects and cancels the system, adjustment at the time of release is not required, and even a user who is not familiar with the system can force the system by simply canceling the system. There is an effect that the setting can be canceled.

In addition to the effect at the time of cancellation, in the case of the above example, the value of an arbitrary memory area of the controller is forcibly rewritten during system operation, and subsequent writing to this forcibly set memory area is performed ( Writing of normal value) can be prohibited until the above cancellation is performed, so that the system operation can be continued stably. In this method, the correction pattern of forced setting cancellation is associated with the variable (memory). When canceling the forced setting, the correction pattern associated with the variable is used to return the value so as not to interfere with the operation of the system.

Furthermore, when the user defines the system configuration, each device is associated with the correction pattern when the forced setting is canceled, and the "correction pattern assigned to the device" is automatically associated with the memory by the compiler function. When the forced setting is canceled, the forced setting is safely canceled using the associated correction pattern.

1 Network 2 Support device 11 Front-end compiler 12 Back-end compiler 13 Source code 14 Intermediate code 15 Machine language object 16 Variable-address correspondence Table 21 Device-correction pattern DB (template)
22 System configuration definition 23 System configuration information 24 Device-correction pattern correspondence table 25 Address-correction pattern correspondence table 30 Controller 31 Program execution management unit 32 Memory 33 Machine language object 34 Address-correction pattern correspondence table 35 Forced ON address list 36 Correction pattern 41 Device (variable name)
42 Attribute 43 Device identification information 44 Address 45 Correction pattern 51 Address 52 Correction pattern 53 Executing flag 61 Control number 62 Forced ON memory address 63 Source value 64 Correction pattern 65 Executing flag 66 Forced setting value 67 Number of executions 68 Start time

Claims (10)

A controller system comprising a support device and a controller,
The controller
A correction pattern storage means for storing one or more correction patterns,
Correspondence relationship storage means for storing the correspondence relationship between an arbitrary variable in the program and the arbitrary correction pattern, and
When a forced setting is made to forcibly rewrite the value of the variable corresponding to the device when the device to be controlled by the controller is abnormal, the normal value previously stored in the memory address assigned to the variable is set. A compulsory setting means that stores the compulsory setting value instead of
If the forcing of the said variables are released, along with the execution of the program, when said correspondence relationship storage unit is the correction pattern corresponding to the release target variables, the corresponding correction pattern By executing the forced setting canceling means, the stored value of the memory address of the variable to be released is gradually brought closer to the normal value from the forced setting value .
Have a,
The normal value is a value obtained by a predetermined process related to the variable by executing the program, and the controller normally stores the normal value in the memory address assigned to the variable.
A controller system that features that. In the correspondence relationship stored in the correspondence relationship storage means, the associated correction pattern is registered in association with the memory address assigned to the variable for each variable to which the arbitrary correction pattern is associated. The controller system according to claim 1 , wherein the controller system is characterized by being The support device is
User arbitrarily to create the correction pattern, the controller according to claim 1 or 2, characterized in that the correction pattern to have a correction pattern managing means to be stored in the correction pattern storage means is transferred to said controller system. The support device is
An arbitrary correction pattern is associated with an arbitrary variable, and the correspondence is generated based on the association result and an arbitrary memory address allocation result for each variable when compiling the program. controller system according to claim 2, characterized in that have a correspondence relation management means for storing in said correlation storage means by transferring relationship to said controller. The support device is
Arbitrarily by setting the forcing value corresponding to the desired variable, a memory address and forcible setting value of the number of the modified, have a first indication means for notifying the controller along with an indication of forcing,
In the controller
To force setting for the given variable is performed, the controller system of claim 1, wherein it is a case of receiving a notification instruction means first. The support device is
It further has a second instruction means for notifying the controller of the forced setting release command in response to an arbitrary instruction.
In the controller
When said forcing is released, the controller system of claim 1, wherein it is a case of receiving the releasing command to the variable. The controller
It also has a compulsory setting management information storage means for storing predetermined information about variables being forcibly set.
The fifth aspect of claim 5 , wherein when the compulsory setting means receives the notification by the first instruction means, the notified memory address and the compulsory setting value are newly registered in the compulsory setting management information storage means. Controller system. The controller system according to claim 7, wherein the forced setting canceling means deletes the corresponding information from the forced setting management information storage means after returning the stored value of the memory address to the normal value. The controller in a controller system having a support device and a controller.
A correction pattern storage means for storing one or more correction patterns,
Correspondence relationship storage means for storing the correspondence relationship between an arbitrary variable in the program and the arbitrary correction pattern, and
When a forced setting is made to forcibly rewrite the value of the variable corresponding to the device when the device to be controlled by the controller is abnormal, the normal value previously stored in the memory address assigned to the variable is set. A compulsory setting means that stores the compulsory setting value instead of
If the forcing of the said variables are released, along with the execution of the program, when said correspondence relationship storage unit is the correction pattern corresponding to the release target variables, the corresponding correction pattern By executing the forced setting canceling means, the stored value of the memory address of the variable to be released is gradually brought closer to the normal value from the forced setting value .
Have a,
The normal value is a value obtained by a predetermined process related to the variable by executing the program, and the controller normally stores the normal value in the memory address assigned to the variable.
A controller that features that. The support device in a controller system having a support device and a controller.
Wherein optionally together to create one or more correction pattern to the user, let associate any of the correction pattern for any variable in any program to be executed by the controller, the association result to the one correction pattern by storing in the controller, when forcibly rewrites forcing the value of the corresponding variable to the instrument at the time of abnormality of the apparatus to be controlled by the controller is released, associated with the variable to be the release the correction pattern that is have a release support means to be executed by the controller,
The normal value is a value obtained by a predetermined process related to the variable by executing the program, and normally, the normal value is stored in the memory address of the controller assigned to the variable.
The correction pattern is a process of gradually approaching the stored value of the memory address of the variable to be released from the forced setting value to a normal value by being executed by the controller.
A support device characterized by that.