KR100271596B1 - Analysis and real-time execution method of a function block type process control program - Google Patents

Abstract

PURPOSE: An interpretation and real time execution method of a function block type process control program is provided to define a unit element of a control operation as a primitive function for a program formation and execution for a process control and easily use a function block formed by grouping a high frequency portion as one element like a service routine of a computer language for thereby implementing an efficient control program. CONSTITUTION: A function block is interpreted. A function block source function group arrangement which includes a unit arrangement with respect to each source function of the function block is generated. A function block source function code arrangement which includes a pointer which indicates a function block source function group arrangement with respect to a source function included in the function block is generated. A function block region variable arrangement is generated for storing variables used in the function block. Source function group arrangements which include a unit arrangement with respect to the source function are generated. A source function code arrangement which includes a pointer is generated. System region, input and output and region variable arrangements are generated for storing the variables. A function block source function code arrangement is copied to the source function code arrangement.

Description

How to interpret functional block type process control program and execute it in real time

The present invention relates to a method of interpreting and executing a process control program in a process control system, and more particularly, to a function block in which a primitive function which is a unit element of a control operation and a combination of primitive functions having a high frequency of use are grouped and defined as a single object. It relates to a method of interpreting and executing a process control program that includes.

In order to strengthen competitiveness through productivity improvement and actively respond to the demands of various markets, researches on automating all processes including the automation of unit machines (various actuators) using a process control system are being actively conducted. Moreover, from the early 1970s, the development of microprocessors introduced innovative changes in automation control devices. Based on this, automation using digital computers has been attempted in the fields of power generation, steelmaking, chemical process and building automation. This process control system is the host computer responsible for process management, monitoring, and planning, the central controller responsible for sequential and non-sequence control, and direct and remote control for input and output of various sensor signals and actuator control signals. It may be configured as an input / output device.

In order to execute process control in such a system, a user program for controlling the control object, that is, a control program, must be created. The control program can be written in C, C ++, PASCAL, etc., but it is inconvenient to use in the field and needs to understand the characteristics of the control system in detail. logic controller) Ladder diagram, a programming language, is used. However, since the complexity of the ladder diagram increases exponentially as the system gets bigger, it is difficult to solve the problem when it occurs, it is difficult to reuse the program because it is difficult to modularize the program, and it is difficult to read and understand programs written by others. There are disadvantages.

Therefore, according to the present invention, a unit element of the control operation is defined as one primitive function to compensate for the disadvantages of the ladder diagram and to create and execute a program suitable for process control. It provides a method of interpreting and executing a process control program that efficiently implements a control program by making functional blocks defined as a single object easily called and used as service routines of general computer language. The control program created in accordance with the present invention is converted into a textual language understood by the central controller by the host computer and downloaded to the central controller. The central controller interprets the control program expressed in a literal language, creates and stores a data structure for execution, and executes it according to the execution signal from the host computer.

According to the present invention, a plurality of functional blocks-each functional block is one of a plurality of preset functional blocks, each functional block includes a plurality of preset primitive functions, and each of the plurality of primitive functions Belongs to one of a number of groups-in terms of how to interpret and execute a control program consisting of a number of primitive functions,

(1) analyzing the functional blocks,

(11) generating a function block primitive function group arrangement 130a including a unit array for each of a plurality of primitive functions included in the function block;

(12) generating a function block primitive function code array 120 including a pointer to the function block primitive function group arrangement for primitive functions included in the function block for each type of function block;

(13) generating a function block local variable array 95 for storing variables used in each type of function block,

A function block analysis step comprising:

(2) interpreting the control program,

(21) generating a primitive function group arrangement (110a, 110b) including a unit array for each of the primitive functions in the control program;

(22) generating a primitive function code array 100 including a pointer to the primitive function group arrangement;

(23) generating system global, input / output and local variable arrays 70 and 80 for storing variables used in the respective primitive functions;

(24) copying the function block primitive function code array 120 corresponding to each function block to the primitive function code array 100 when each function block is called;

(25) copying the contents of the function block primitive function group array 130a corresponding to each function block to the primitive function group arrays 110a and 110b when each function block is called;

(26) generating a function block global variable array 90 by copying the contents of the function block local variable array 95 corresponding to each function block when the function blocks are called;

A control program interpreting step comprising a

(3) executing the control program using the primitive function code array, the primitive function group array, the system global, input / output and local variable arrays, and the function block global variable array;

Provided is a control program interpretation and execution method comprising a.

1 is an overall system configuration of the present invention.

2 illustrates a relationship between arrangements created in accordance with the present invention and used when executing a program.

3 illustrates a method of copying functional block arrays into primitive functional arrays.

4 illustrates a method of copying a functional block local variable into a functional block global variable.

<Explanation of symbols for the main parts of the drawings>

5: shared memory

10: parent computer

20: central controller

30: lower network controller

40a, 40b: direct input / output device

50a, 50b: remote input / output device

60a, 60b: terminal device

100: primitive function code array

120: function block native function code array

Hereinafter, an embodiment of the present invention will be described in detail with reference to the accompanying drawings. First, referring to FIG. 1, an example of a process control system in which the method of the present invention may be practiced, the process control system 1 is generally characterized by an upper computer 10, a central controller 20, a lower network controller ( 30), direct input / output devices 40a and 40b, remote input / output devices 50a and 50b, terminal devices 60a and 60b, and the like, and each device is connected via a bus as shown. The host computer 10 is generally responsible for system structure definition, system variable definition, process control program creation, process monitoring, and the like. The system structure definition defines the structure of the entire system (eg, the number of input / output, the number of network nodes, etc.), and the system variable definition defines the system global variables and system input / output variables for use in the system. After the system structure and variables are defined in the host computer 10, a process control program to be executed in the process control system 1 is created. Preferably, the user can create a control program by editing each primitive function and function block expressed in a graphic form using an editor (for this, Patent Application No. 97-21703 filed by the same applicant as the applicant of the present invention). See).

The process control program created in the host computer 10 is converted into a character language understood by the central controller, for example, in the form of ASCII code, and the central controller 20 through the host network (eg, Ethernet, 15). Will be downloaded. The downloaded process control program converted into a textual language is interpreted by the central controller 20 and then executed in a real time, multi-processing manner.

The central controller 20 is composed of a control program processor, an upper networking unit in charge of networking with the upper computer 10, a direct input / output unit control unit, and a lower networking unit in charge of networking with a remote input / output device. The central controller 20 analyzes the control program downloaded from the host computer 10 through the host network 15 and stores the data structure created as a result of the analysis in the shared memory 5. In addition, the values inputted through the direct input / output devices 40a and 40b and stored in the shared memory 5 and input from the remote input / output devices 50a and 50b are transmitted through the lower network 45 to the shared memory 5. The control program is executed using the stored values and the result is directly output to the input / output devices 40a and 40b or transmitted to the remote input / output devices 50a and 50b through the lower network 45. The execution result of the control program is sent to the host computer 10 through the host network 15 as needed to be used for process monitoring and the like.

The direct / remote input / output devices 40a, 40b, 50a, and 50b are composed of devices for inputting and outputting various analog and digital signals. The direct input / output devices 40a and 40b are connected to the same bus as the central controller 20 (for example, a VME bus 25), so that the input / output devices of the terminal devices 60a relatively close to the central controller 20 can be connected. The remote input / output devices 50a and 50b are responsible for the input / output of the terminal devices 60b remote from the central controller. Examples of the terminal device include an electric motor, a hydraulic driver, a switch, a lamp, a relay, a sensor, and the like which are subject to control or provide an input used for control. The remote input / output devices 50a and 50b exchange information with the central controller 20 through networking using a field bus (for example, Profibus, 45).

The following describes the process of interpreting and executing the functional block type process control program briefly described above in more detail. The variables used in the process control program of the present invention, which are composed of primitive functions and functional blocks, are described in order to represent respective ports and terminals of the input / output device defined in the system configuration definition of the host computer 10. System I / O variables, variables commonly used in the control program, system global variables that can be referenced and modified from any position in the control program, system local variables used only within a certain area of the control program, and predefined function blocks are called. Function block variables used to do this. Depending on the characteristics of these variables, one of the following types is logical, integer, or real number. For variables indicating ON / OFF status, use logical variables, those with integer values use integer variables, and real values if real values are required. do.

The system input / output variables and system global variables are defined in the system variable definition at the host computer 10 and are downloaded to the central controller 20 together with the control program. The central controller 20 arranges this as a system-wide and I / O variable array (70 in FIGS. 2 and 3) on the shared memory 5, and uses the unique name in the array when interpreting or executing the control program. You will find a location.

For system local variables, place the system local variable array (80 in FIG. 2) on the shared memory 5 and allocate one memory space according to the type (logical, integer or real) of each variable. It is referred to or modified as the ID (identification number) of the variable.

On the other hand, the same function block can be executed several times in the control program, which is made possible by declaring a plurality of function block variables described above for a predetermined function block and calling different function block variables. Therefore, when interpreting the function blocks, a function block local variable array (95 in FIG. 4) for local variables used only within a predetermined function block and a global variable to be used when executing such a function block in a control program are used. Function block global variable array (90 in Figs. 2 to 4).

As described above, the system global variables and the system input / output variables are allocated separate areas on the shared memory 5 of the central controller 20 when they are downloaded from the upper computer 10 to the central controller 20. Local variables in the function block, I / O independent variables used to call the function block variables, and internal parameters inside the primitive function described later may occur or disappear depending on the configuration of the control program. Since memory is wasted, it is advantageous to allocate and use one memory space whenever needed in a certain common area. Therefore, whenever the logic, integer, or real system local variable array 80 or the functional block local variable array 95 managed by the central controller 20 during the interpretation of the code in the control program or the function block is required, Allocates space one by one and manages the index of the array as its own address.

When the control program is interpreted, a primitive function code array (100 in FIGS. 2 and 4) for indicating which primitive functions are configured, and each primitive function is classified according to its characteristics as described below. Two primitive function group arrays 110a and 110b (of which only the primitive function group 1 and 2 arrays are shown) are created. As shown in Figure 2 and 4, the primitive function code array 100 is composed of a number of units, one unit is configured as follows.

[1] Group number indicating the primitive function group to which the primitive function belongs

[2] Pointer to the location of the primitive function in the primitive function group array

[3] Pointer to next place in the source code array (next)

[4] A pointer to where to execute if the branch condition is false in the primitive code array.

Primitive functions used in the present invention include arithmetic operation function, trigonometric function, bitwise logical operation function, comparison function, bit shift function, selection function, type conversion function, mask ( mask functions, bistable functions, edge detection functions, and timer functions. When one primitive function is interpreted, one unit of the primitive function code array 100 and five primitive function group arrays described above are allocated one unit from the array to which the primitive function belongs.

All primitive functions used in the present invention are divided into the following primitive function groups according to the number of independent input / output variables and the number of internal parameters.

[1] Primitive Function Group 1: Primitive Functions with Input Independent Variable 1 and Output Independent Variable 1

[2] Primitive Function Group 2: Primitive Functions with Input Independent Variable 2 and Output Independent Variable 1

[3] Primitive Function Group 3: Primitive Functions with Input Independent Variable 3 and Output Independent Variable 1

[4] Primitive Function Group 4: Primitive Functions with Input Independent Variable 1, Output Independent Variable 1, and Internal Parameter 1.

[5] Primitive Function Group 5: Primitive Functions with Input Independent Variable 2, Output Independent Variable 1, and Internal Parameter 2.

These primitive function group arrays 110a and 110b are composed of pointers to function codes, input / output independent variables, internal parameters, and the like, respectively, and these pointers point to memory locations in which values of the actual variables and the like are stored. I / O independent variables and internal parameters point to logic, integer or real number values according to the type of primitive function, and what kind of value they should be. Therefore, the appropriate type of variable is used when executing the primitive function. The reason for dividing primitive functions into five groups is that using the same array structure for all primitive functions wastes memory because the number of input / output independent variables and internal parameters are different for each primitive function. Because.

FIG. 2 illustrates the relationship between the primitive function code array 100 and the primitive function group arrays 110a and 110b and several variable arrays. As shown in FIG. The rest of the intermediate arrays just contain information (pointers) to refer to them.

Next, a function block, which is a tool that combines a plurality of primitive functions and performs a new function, will be described. Before downloading the control program from the host computer 10 to the central controller 20, the function block program for the function blocks defined in the system or separately defined by the user by binding several primitive functions are downloaded. An example of such a function block program is shown in Appendix 1, which shows that it is a combination of several primitive functions. In the example of subprogram of Attachment 2, which is a part of the whole control program, declares multiple function block variables "FBvar1" and "FBvar2" for the function block type defined as "SAMPLE" in Attachment 1. It can be seen that. By calling each of these, the same function block is executed twice.

Referring to the process of interpreting the functional block, the functional block program describing the contents of each functional block is first interpreted by the central controller 20, and the information about the function and the use variables is made and the memory required for the allocation is allocated. Subsequently, when the control program is interpreted, the information of the corresponding function block type prepared in advance is copied to the function block variable of the registered type. This copying process is shown in FIGS. 3 and 4. The function block primitive code arrays produced by the interpretation of the function blocks also have a data structure that is almost similar to that of the primitive functions described above. That is, the function block primitive function code array 120 for indicating which primitive functions are configured inside the function block program has the same structure as the primitive function code array 100 and is included in a predetermined function block program. Contains array units corresponding to each primitive. Each primitive function group has five functional block primitive function group arrays 130a having the same structure as the primitive function group arrangements 110a and 110b described above, and their roles are the same as in the primitive function. In addition, the function block local variable array 95 is set up for I / O independent variables and local variables used in the function block program, and memory is stored in one of logical, integer, or real number variables according to the type of variable needed for the function block program analysis. Space is allocated.

After the analysis of the function block program is completed, the control program is interpreted. When one function block variable is called in the control program, the arrays created when the function block program is interpreted are copied and used to execute the control program. That is, as shown in FIG. 4, the functional block primitive function code array 120 is a primitive function code array 100, and the five functional block primitive function group arrays 130a correspond to corresponding primitive function group arrangements ( 110a and 110b, the functional block local variable array 95 is copied to the functional block global variable array 90 and the latter are used at the time of execution of the control program, respectively. The reason for this is that, as described above, several different function block variables for the same function block type can exist in one subprogram (that is, the same function block can be called multiple times), so that each function block variable is separate. This is because we need to allocate the area of.

The reason why the functional block global variable array 90 is configured separately from the system global and I / O variable array 70 is that the contents of the functional block global variable array 90 are defined by the user. Unlike the system global variable, because it is assigned and managed within the central controller 20. On the other hand, system input / output variables or system-wide variables can be used directly as input / output independent variables of function block variables. In this case, the pointers are copied as they are and eventually designate the same variables (see FIG. 3). In order to manage the function blocks interpreted through the above procedure, the function block register array is provided, and the inside thereof is configured as follows.

[1] Name corresponding to type of function block

[2] Number of input / output independent variables and pointers to them

[3] Function block Start and end pointers containing the contents of the function block in the source code array.

[4] Start and end pointers containing the contents of the functional block in the five functional block primitive group arrays.

[5] Function block Local variable array start and end pointers of all kinds of variable arrays used by the function block.

When interpreting the control program, the name of the function block variable declared in the control program is found in the function block register array, and if there is a name, the information in the function block array is used to determine the type of function block variables. You will decide which part to copy.

The control program can be regarded as a combination of several independent or linked subprograms, and Attachment 2 is an example of such a subprogram. The subprogram has the following components.

[1] Sub program name

[2] Declaration section of local variables in subprograms

[3] Declaration unit of function block variable in subprogram

[4] subprogram

Each subprogram is classified according to its name, and local variables are allocated one of the corresponding types of memory space among logical, integer, and real variables in the system local variable array and have a pointer to the location. In the case of a function block variable, the function block register array is searched to find out whether the type of the variable is one of the predefined function blocks, and if the function block exists, as mentioned in the description of the function block. Copy and use as many of the function block arrays as needed. By interpreting the program part of the subprogram, arrays are created as mentioned in the description of primitive functions, function blocks, etc., and these arrays are used when the subprogram is executed. In addition, it is necessary to manage the information on the area occupied by each subprogram in the entire control program, which is made of a subprogram array having the following components.

[1] Start and end pointers in the source function code array occupied by each subprogram

[2] Start and end pointers of the five primitive function group arrays occupied by each subprogram

[3] Start and end pointers of three variables in the system local variable array used by each subprogram

A function block is eventually made up of a combination of primitive functions that constitute it, so a subprogram can be regarded as a combination of primitive functions that constitute it. Therefore, marking the start and end of a subprogram can be said to be the start and end pointers of the source code array specified in the subprogram array. In addition, the reason for separately managing start and end pointers for variables used in each subprogram is to know how much memory the entire or each subprogram occupies for resource management.

Through this process, when all the control programs are interpreted and all necessary data structures are made, the execution starts with the start and end pointers of the subprogram to be executed using the subprogram array. It executes primitive functions one by one from the starting pointer position, and reads the function codes of primitive functions, pointers to I / O variables, and pointers to internal parameters from primitive function group arrays, and uses them to write or array the variable values required for the function block global variable array. Run the program by reading the variable value from the. This execution process will be described with reference to FIG. 2 again. First, a primitive function group number to which a corresponding primitive function belongs is read from a pointer of a primitive function code array to start a corresponding subprogram. Next, the pointer in the primitive function group array is used to find the position in the primitive function group array. Find the function code that represents the role of the primitive function as seen from that location, read the actual values from the array of variables pointed to by the pointers corresponding to the input arguments and internal parameters, perform the necessary operations according to the function code, and then print The values are stored in the variable array pointed to by the pointers to the independent and internal parameters. This completes the execution of one primitive function, returns to the primitive function code array, compares the next execution pointer value with the subprogram end pointer value read from the subprogram array, and repeats this process if it is not the end. As a result, the subprogram is executed. The control program composed of the subprogram is executed by executing the subprogram as described above.

Creating a control program by using an editor in the upper computer in the above way, it is easy to create or modify the program, easy to grasp the overall flow or solve the problem, it is easy to reuse the program once used. .

According to the present invention, since the control program, which is converted into a character language by the host computer and transmitted, is interpreted in advance into a data structure required for execution, the analysis takes time, but the execution does not take any time to interpret the program. The operation occurs by referring to the data structure that has already been created, so real-time execution, which is one of the biggest problems in the control program execution, is guaranteed.

In addition, by creating separate data structures for different control programs and actually executing them, only pointers to those data structures are remembered and tracked so that multiple executors can be created from the same executable code (program). Good and easy to debug because the shared memory where each control program is interpreted is managed separately.

It is also highly portable even if the central controller is changed by developing with a general-purpose UNIX tool (eg lex & yacc).

In addition, since the amount of the control program and the amount of shared memory of the central controller required are almost proportional, it is easy to set the system scale according to the control object.

Appendix 1: Example of Function Block Program

FUNCTION_BLOCK SAMPLE

VAR_IN

IN1: BOOL; IN2: INT; IN3: REAL;

END_VAR

VAR_OUT

OUT1: INT; OUT2: INT;

END_VAR

VAR

tmp: INT;

END_VAR

IF IN1 = TRUE

THEN tmp: = 23;

ELSE tmp: = 77;

END_IF

OUT1: = tmp * 13;

OUT2: = INT (IN3) * 3;

END_FUNCTION_BLOCK

Attachment 2: An example of a subprogram

SUB_PROGRAM EXAMPLE

VAR

Local INT: INT;

Local BOOL: BOOL;

Local REAL: REAL;

END_VAR

FUNCTION_BLOCK_VAR

FBvar1: SAMPLE;

FBvar2: SAMPLE;

END_FUNCTION_BLOCK_VAR

IF GBreturn = TRUE

THEN local INT: = 10;

ELSE local INT: = 20;

END_IF

GItarget: = GIrefer + local INT;

Grsval: = SIN (GItarget);

FBvar1 (IN1: = TRUE, IN2: = 10, IN3: = Grsval);

Gireturn1: = FBvar1.OUT1;

Gireturn2: = FBvar1.OUT2;

FBvar2 (IN1: = TRUE, IN2: = 20, IN3: = Grsval);

Gireturn3: = FBvar2.OUT1;

Gireturn4: = FBvar2.OUT2;

END_SUB_PROGRAM

Claims (4)

A plurality of functional blocks, each functional block being one of a plurality of preset functional blocks, each functional block comprising a plurality of preset primitive functions, each of the plurality of primitive functions being a plurality of groups In the method of interpreting and executing a control program consisting of and a number of primitive functions, (1) analyzing the functional blocks, (11) generating a function block primitive function group arrangement 130a including a unit array for each of a plurality of primitive functions included in the function block; (12) generating a function block primitive function code array 120 including a pointer to the function block primitive function group arrangement for primitive functions included in the function block for each type of function block; (13) generating a function block local variable array 95 for storing variables used in each type of function block, A function block analysis step comprising: (2) interpreting the control program, (21) generating a primitive function group arrangement (110a, 110b) including a unit array for each of the primitive functions in the control program; (22) generating a primitive function code array 100 including a pointer to the primitive function group arrangement; (23) generating system global, input / output and local variable arrays 70 and 80 for storing variables used in the respective primitive functions; (24) copying the function block primitive function code array 120 corresponding to each function block to the primitive function code array 100 when each function block is called; (25) copying the contents of the function block primitive function group array 130a corresponding to each function block to the primitive function group arrays 110a and 110b when each function block is called; (26) generating a function block global variable array 90 by copying the contents of the function block local variable array 95 corresponding to each function block when the function blocks are called; A control program interpreting step comprising a (3) executing the control program using the primitive function code array, the primitive function group array, the system global, input / output and local variable arrays, and the function block global variable array; Control program interpretation and execution method comprising a. The apparatus of claim 1, wherein each primitive function has a predetermined input / output variable and an internal parameter, and is divided into a plurality of groups according to the preset input / output variable and an internal parameter, and the unit array is assigned to a function code and an input / output variable. A control program interpretation and execution method that includes a pointer to a pointer to a pointer to an internal parameter. The method of claim 1, wherein the primitive function code array, A group number indicating which group the primitive belongs to, Pointer to the portion of the primitive group that corresponds to the primitive. A pointer to where to execute next in the primitive code array, Pointer to the place to execute when branch condition is false in the primitive code array Control program interpretation and execution method comprising a. The method of claim 3, The control program includes a plurality of subprograms, Each of the subprograms is executed by executing primitive functions one by one using a pointer to the beginning and end of the primitive function code array for each subprogram, Each primitive function reads a function code of a primitive function, a pointer to an input / output variable, a pointer of internal parameters in the primitive function group array, and indicates the pointers of input variables and internal parameters in a system global, input / output and local variable array. Interpret the control program by reading the actual values, performing the necessary operations according to the function codes, and then storing them in the system global, I / O and local variable arrays where the pointers to the output and internal parameters point. How to run.

Images