KR101339356B1 - Script Engine Control Device for the Automation of Graphic Builder - Google Patents

Abstract

The present invention relates to a script engine control apparatus for automation of a graphic builder. In particular, a user can freely write a program and has a built-in interpreter capable of interpreting a script command. The effect of making it possible to process can be expected.

Graphic Builder, Script Engine, Automatic Control, Script Input Section, Script Processing Section, Script Output Section

Description

Script Engine Control Device for the Automation of Graphic Builder}

The present invention provides a script engine control apparatus for automation of a graphic builder that allows a user to freely write a program and has a built-in interpreter capable of interpreting a script command, thereby enabling graphic processing of various operations and logical operations on tags. It is about.

Graphic Builder is a Human-Machine Interface (HMI) development tool developed to develop ship and land high-level systems. The composition of the Graphics Builder is largely divided into editor and runtime.

The main function of the editor provides the function to create the screen necessary for monitoring and control by using the drawing function, symbol registration, and alignment function, and the runtime displays the process chart screen created through the editor and performs control according to the set dynamic characteristics. Provides the ability to

These graphic builders provide a graphic editor function that allows the user to freely configure the process diagram screen of the ship and onshore high-level systems, and also read and control the dynamic characteristics created and saved in the graphic editor and perform the control according to the characteristics. Provides builder runtime functionality.

However, the existing system allows the user to freely create graphical elements by using an editor, but in reality, the elements that are directly controlled dynamically have limitations because the developer must handle them at runtime.

Accordingly, the present invention for solving the above problems is implemented as a function that allows a user to freely write a program, and has a built-in interpreter capable of interpreting script commands to perform graphics processing for various operations on a tag and logical operations. It is possible. For example, a graphic builder that allows scripts to be written when a key is pressed to open a window or change its value, and to perform actions when an event such as a timer, keyboard, tag data changes, or a mouse click occurs. It is an object of the present invention to provide a script engine controller for automation.

The present invention for achieving the above object is a script engine control device for the automation of the graphic builder, a script function consisting of a user-created function registered by the user's needs while using the basic function and script provided by the developer to the script user And, it is easy to be written by the user and has the language form similar to C so that the user can make the desired function in the desired position, and has the control statement structure such as if statement, switch statement, while statement, for statement, and return statement. Script code designed to support the operation, assign local variables and use them by declaring local variables, and register variable names, variable types, and initial values in the global variable declaration field to use global variables. consists of a global variable table that supports variables of type, double, boolean, and string And the encrypted input; A script processing unit which receives a function, a global variable / local variable, and a written script code as an input and processes a user script through a syntax execution processor; A script output unit which outputs the result processed by the script processing unit; .

According to the present invention, the user can freely write a program, and by embedding an interpreter capable of interpreting a script command, it is possible to expect the effect of enabling graphic processing for various operations and logical operations on tags.

Hereinafter, exemplary embodiments of the present invention will be described with reference to the accompanying drawings, FIGS. 1 to 16.

The terms defined in describing the present invention have been defined in consideration of the functions of the present invention and should not be construed to limit the technical elements of the present invention.

According to the drawings, the present invention, in the script engine control apparatus for the automation of the graphic builder, a script function consisting of a basic function provided by the developer to the script user and a user production function registered by the user's needs while using the script And, it is easy to be written by the user and has the language form similar to C so that the user can make the desired function in the desired position, and has the control statement structure such as if statement, switch statement, while statement, for statement, and return statement. Script code designed to support the operation, assign local variables and use them by declaring local variables, and register variable names, variable types, and initial values in the global variable declaration field to use global variables. A global variable table that supports variables of type, double, boolean, and string. Script and input; A script processing unit which receives a function, a global variable / local variable, and a written script code as an input and processes a user script through a syntax execution processor; A script output unit which outputs the result processed by the script processing unit; .

In addition, the script processing unit declares a parser node for a parser during script processing, and when a constructor passes a string of scripts as an argument, a constructor calls a tokenizer and a parser, and the tonizer performs a lexical analysis in a script engine. The parser is characterized in that the parsing step,

The tokenizer (lexical analysis step) reads the script code input by the input unit in character units, obtains it as a token, splits it into semantic units, and hands it to the parser, 'n' means a carriage return, The number of '＼n' is counted to find out the information on the line where the token is located, and the token processing method is characterized by the tokenizing process to achieve the greatest meaning from the front according to the C standard method. ,

The parser (parsing step) is performed when passing the lexical analysis step, and performs parsing based on the token information generated in the lexical analysis step, but checks whether the minimum unit of grammar checking is checked and returns the basic unit Base Case Check step: Determines whether a reserved word such as an if statement, a for statement, a while statement, a return statement, a switch statement, etc., calls each reserved word parser, and checks ';' in other cases. Syntax checking step to call each one: If it does not pass the above syntax checking step, it is determined as a function (or formula). Function parsing step: Calling a function parser: After processing in the syntax checking step, it is a syntax suitable for each reserved word parser. A reserved word parser step of parsing according to: a function parser step of parsing a tree in an appropriate shape according to operator priority.

The script engine provided by the present invention was developed to provide a convenience that a user can freely utilize the program by writing and operating the program externally.

The proposed script engine is implemented as a function that a user can freely write a program, and it has a built-in interpreter that can interpret script commands, and can perform graphic processing on various operations on tags and logical operations.

For example, you can write a script that opens a window or changes its value when a key is pressed, and what happens when an event such as a timer, keyboard, tag data changes, or a mouse click occurs.

The main parts of the script engine are divided into script input unit, script processing unit, and script processing unit.

Script input section

The script input unit of the script engine is classified into three types as shown in FIG. 1.

1. Script functions: Script functions are divided into basic functions and user-created functions. Basic functions are functions that developers provide to script users. Generally, system-related functions such as window functions, time functions, etc., which can control window components, and Refers to mathematical functions and database support functions for operations. A user-created function is a function that is registered as needed by a user while using a script.

2. Script code: Invented script has a language similar to C and has control statement structure such as if statement, switch statement, while statement, for statement, and return statement, and supports logical operation and arithmetic operation. It is also designed to allow local variables to be assigned and used by declaring local variables. Script users can use script code that is easy to write to create the desired functionality in the desired location.

3. Global Variable Table: To use a global variable, you must first declare and register the variable name, variable type, and initial value in the global variable declaration field. Supported variables support basic integer type, double type, boolean type and string type, and additionally support unsigned long type to support COLORREF type.

◆ Script processing department ◆

The script processing unit is also called the core engine.

The script engine core, which is the core of the script processing unit, takes as input the functions of the script input unit, global variables / local variables, and the script code that is created, and processes the user script through the syntax execution processor.

Declare a parser node for the parser and pass a string of scripts as arguments. The constructor calls the tokenizer and parser.

2 illustrates the overall structure of a script engine.

The tokenizer refers to the lexical analysis stage in the script engine, and the parser refers to the parsing stage.

The following describes the process of processing the toner and parser briefly.

(1) tokenizer (lexical analysis)

Tokenizer (lexical analysis) reads the script code written through the script input unit in character units, obtains it as a token, splits it into semantic units, and passes it to the parser. 'n' means carriage return, which counts the number of 'n's together to find out on which line the token is located.

The token processing method was tokenized to have the greatest meaning from the beginning according to the C standard method.

If an error is found or found as an error in the tokenizer, it is added to the error table.

If no errors were found during the tokenizer, go to the parser step.

However, if an error is found, it stops running and notifies the user of the error message found.

3 shows a schematic diagram of a tonizer (lexical analysis process).

(2) parser (parse)

When passing through the tokenizer (lexical analysis step), a parser (syntax analysis step) is performed, and syntax analysis is performed based on token information generated in the lexical analysis step.

At this time, the token sequence is received to construct a parser tree. Errors in lexical analysis simply check that the scripting language you have written is grammatically correct, but errors in parsing can be found in lexical analysis, such as incorrect function names or spaces. If there are no errors, that is, grammatical errors in the execution of the script, they are added to the error table. If there are no errors, the parsing process is performed.

In the parsing phase, parsing is performed through the top-down recursive call. It is called by changing the index of the part to be parsed while passing the token vector.

4 is a diagram illustrating a parser (syntactic analysis) process.

The parser process is as follows:

As a base case check step, it checks whether the minimum unit of grammar check is checked and returns. As a syntax check step, it determines whether it is a reserved word such as if statement, for statement, while statement, return statement, and switch statement. Invoke the corresponding reserved word parser. Otherwise, each call itself by checking ';'.

As a function parsing step, if the above syntax checking step is not performed, it is determined as a function (or an expression) and the function parser is called.

After processing in the syntax check, it processes the reserved word parser by parsing it according to the grammar for each reserved word parser. The tree created for each reserved word is different.

Finally, it takes care of the function parser step, which parses the tree into the appropriate shape based on operator precedence.

Script output

The core structure of the engine as the script processing unit and the script output unit are configured as shown in FIG.

The result processed by the script processing unit is output to the script output unit.

Graphic Builder supports scripting of five attributes, especially dynamic attribute scripts, which require a lot of processing.

Results are assigned based on the instance to which the script is applied, which requires a script management structure to support complex processing and multiple scripts.

The scripting language has the same syntax as C ++, but is composed of scripting syntax to reduce ambiguity, and supports reserved words such as if / for / while / switch / return / continues / break and the conditional expressions ==,! =,> , <, <=,> =, &&, || Provides an expression such as The contents of other detailed scripting languages are large and are omitted.

In the script engine as described above, a script editor is required to provide a user with a script input unit conveniently and clearly.

In the graphic builder script editor, the script writing part provides an input window as shown in FIG. 6, and the user does not need to compile the entire program using the control syntax and the functions provided by the script writing part. You control each dynamic element through.

First, the user declares the global variable in the ⑤ global variable register by name, variable type, and initial value. Also, if a user wants to create a new function while writing, ⑥ declare and write a new function in the user function register.

④ The tag registration unit loads the tag list in the shared memory to be used in the project and provides a window for selection. This function is important because it outputs script result by performing logical operation using tag.

When the writing is completed, the grammar check function and the execution function provided in the script menu are first checked. If a grammatical error is found, an error message is displayed in the form of a message box. Press to execute.

The result is displayed in the result display part or applied at runtime to the component that creates the script.

This script editor provides the help function to enhance convenience by supporting grammar explanation, example, provided function structure and writing method that users can make even if they are not familiar with program writing.

7 illustrates a screen of the developed script editor, and FIG. 8 illustrates a tag registration screen that is popped up when an execution button is pressed in the tag registration unit. 9 illustrates a window that pops up when the execution button of the user registration function is pressed.

Hereinafter, application examples and operation methods of the present invention will be described.

In order to explain the application case, it explains how to control the window control etc. to apply to the runtime module of the graphic builder and to experiment with visual effects.

10 illustrates a screen in which a script engine is mounted on an actual runtime module for testing. Each window control shown on the screen is reflected differently depending on the result of the script created by the user through the script editor.

If an error is not found in the grammar check, a message as shown in FIG. 11 appears and a grammar check is performed. If an error occurs, the error message stored in the error table is output.

12 is an error message output window.

FIG. 13 is a color window executed through the getcolor () function, and FIG. 14 shows a result performed by a logical operation of a tag value through the above script control function.

Script functions developed so far provide window control functions, Math functions, tag control functions, and window component control functions.

Window control functions provide basic functions such as print, mbox, localtime, window, dialog, getcolor, play, srand, time, rand, and CreatePath. Here a modal dialog is provided through the dialog () function, and a modal dialog is provided through the window () function.

The Math function provides basic functions such as nsum, nminus, nmultiply, ndivide, dsum, abs, atoi, atof, cos, sin, tan, etc. The tag control function reads a real tag value from shared memory through GetTagValue. .

The window component control functions provide various functions according to component properties such as SetPositionSize, SetSliderPosition, SetFontSize, SetCaption, SetTextColor, SetBackColor, SetFontStatic, SetAddString, SetDeleteString, and SetSliderdPosition. .

User functions are necessary when a user wants to create a new function in addition to a script providing function. This script editor provides the user function definition function.

To create a user-defined function, you first define a user function named SUM whose return value is an integer in the script editor window. If you press the Add / Modify Function button, the user function creation window pops up as shown in Figure 15. Here, we declare two integer global variables, a and b, to be used for SUM calculation, and the code produces return (a + b) ;, checks the syntax, executes it, and registers a function.

Then, the actual user can freely use the registered function in the script editor.

16 shows the result of the user defined function. As you can see from the bottom right, if two Arguments called SUM are registered, and the return value is an integer SUM function defined as in Fig. 15, the user will actually use the code inside the Print statement in the upper left code. You can confirm that the result is correct in Result.

According to the present invention as described above, by applying to a graphic builder for developing a ship and onshore HMI, the user can freely create and apply not only the existing process diagram graphics, but also automatic control function, which is a conventional Automation scripts have been added to the passive graphic builder structure to further enhance the product's competitiveness with its upgraded technology.

1 is a diagram showing a script engine structure of the present invention.

2 is a diagram showing the overall structure of the script of the present invention.

3 is a view showing a tokenizer process of the script processing unit applied to the present invention.

4 is a view showing a parser process of the script processing unit applied to the present invention.

5 is a diagram illustrating a script processing unit and a script output unit of the script engine of the present invention.

6 is a schematic diagram illustrating a script editor.

7 shows an actual screen of the script editor.

8 is a diagram illustrating a tag registration screen by a script editor.

9 is a view showing a user function registration screen by a script editor.

10 is a diagram showing a screen in which a script engine is mounted on an actual runtime module for testing.

11 is a diagram illustrating a screen output state when no error occurs during grammar checking.

12 is a diagram illustrating a screen output state when an error occurs during grammar checking.

13 illustrates a color popup window executed through a getcolor () function.

14 is a view showing a result performed by a logical operation of a tag value through a script control function.

15 illustrates a user-defined function creation window.

16 is a view showing a result of using a user-defined function.

Claims (4)

In the script engine controller for the automation of the graphic builder, While using the basic functions and scripts provided by the developer to the script user, script functions consisting of user-written functions registered according to the user's needs, and C-like languages so that the user can easily write the desired functions in the desired location. It has a form, has control statement structure such as if statement, switch statement, while statement, for statement, and return statement, supports logical operation and arithmetic operation, and is a script code designed to assign and use temporary variable by declaring local variable. In order to use global variables, the script input section consists of a global variable table that first registers the variable name, variable type, and initial value in the global variable declaration field, and supports variables of type integer, double, boolean, and string. Wow; A script processing unit which receives a function, a global variable / local variable, and a written script code as an input and processes a user script through a syntax execution processor; A script output unit which outputs the result processed by the script processing unit; Consists of, The script processing unit declares a parser node for a parser during script processing and passes a string of scripts as an argument, the constructor calls the tokenizer and the parser, and the toner is a lexical analysis step in a script engine. The parser is a script engine controller for the automation of the graphics builder, characterized in that the parsing step. delete The method of claim 1, wherein the tonizer (lexical analysis step) is to read the script code input by the input unit by character unit to obtain a token and split it into semantic units to pass to the parser, 'n' means carriage return, and counts the number of '＼'s together to find out which line the token is on, and the token processing method is based on the C standard. Scripting engine control device for the automation of the graphics builder, characterized in that the processing to achieve the greatest meaning. The method of claim 1, The parser (syntax analysis step) is performed when passing the lexical analysis step, and performs a syntax analysis based on the token information generated in the lexical analysis step, A base case check for checking and returning that the minimum unit of the grammar check is checked; a syntax check for calling a reserved word parser corresponding to each of them while determining whether they are reserved words in an if statement, for statement, while statement, return statement, and switch statement, and otherwise calling each of them by checking ';'; A function parsing function that determines a function (or expression) and calls a function parser if the syntax check does not occur; A reserved word parser that processes the syntax check and parses it according to the grammar for each reserved word parser; And a function parser for parsing the tree in an appropriate shape according to the operator priority. Script engine control device for the automation of the graphics builder, characterized in that made.

Images