OpenSCADAWiki: Home Page En/Doc/VC Aconcept/part6 ...

6.1 Widgets and Libraries -- Done

The objectives of this phase are:

• The implementation of the basis of the architecture "Data model" - "Visualization" in the face of the modules of OpenSCADA system: "UI.VCAEngine" - "UI.Vision".
• Implementation of the basic functions of the data model of VCA in the module UI.VCAEngine:
  • Organization of the storage of the model data of the module UI.VCAEngine in the databases available in OpenSCADA.
  • Writing the scenarios of the data model control of the UI.VCAEngine module by means of the control interface of OpenSCADA.
  • Creating an abstract class of widget (VCA::Widget).
  • Creating the class of widgets library (VCA::WdgLib).
  • Creating the representative classes of the library (VCA::LWidget) and container (VCA::CWidget) widget.
  • Creating the business class of the terminal widget (VCA::PrWidget - the final visualization element).
  • Creating the primary version of the library of the terminal widget, data model of the visualization primitives.
• Implementation of the basic functions of development framework of user interface in the visualization module UI.Vision:
  • Building the basis of the user interface of developing on the QT library.
  • Formation of the navigator through the libraries of widgets and tools for their management.
  • Building inspector of the widget's attributes.
  • Forming the dialogue of the editing the properties of the library.
  • Forming the dialogue of the editing widget's properties.
  • Formation of the graphic editor of the frames and the basis of the graphic editing of the final visualization elements(primitives).

As the result of our work the modules of the data model (UI.VCAEngine) and visualization (UI.Vision) was created. At this stage, the modules implement the mechanisms of UI elements formation. At next stage these elements will be used to form the full-fledged visualization and control interfaces.

Lets consider the results of the each stage's implementation:

The implementation of the basis of architecture "Data model" - "Presentation(visualization)"

In accordance with the static class diagram (Fig.4.10.1) and general requirements there have been implemented the modules "UI.VCAEngine" and "UI.Vision" for the OpenSCADA system. The "UI.VCAEngine" module implements the VCA data model and is the source for subsequent presentation of these data by different mechanisms of visualization. The "UI.Vision" module provides the means of presentation(visualization), based on QT library of version 4 of the Trolltech company.

Connection between the modules of the data model and presentation(visualization) is organized by direct calls (strong links). This method of connection is selected for preliminary abstraction of features of interaction and for concentration on core problems of implementation. Later it is planned the unification and construction of these links through the control interface of OpenSCADA system (weak links). As the result it will be achieved the opportunity of separation the data model and presentation(visualization), with possibility of simultaneous maintenance of different presentation(visualization) mechanisms with the single VCA data model. In addition, it will be possible to estimate the influence of the connection's(link's) type on the performance of the VCA.

Implementation of the basic functions of the VCA data model in the UI.VCAEngine module

The module of the data model(engine) of the VCA contains the container of widgets/frames library. The module provides the predefined library of basic widgets (primitives) with the primary realization of their own properties and processing logic of these properties.

Storage of the widgets' data and widgets' libraries is implemented in the database available in the OpenSCADA system. The database is organized on data ownership to the library. Ie the separate library is stored in the separate group of tables of the one or different databases. The list of libraries of widgets is stored in the index table of the libraries with the name "VCALibs" and with the structure "Libs", of the DB section. A copy of this table is created in each database, which stores data of this module, with the list of libraries contained in the given database. The structure of the tables of the belonging to the library widgets includes:

• {DB_TBL} -- Table of widgets belonging to the library (the structure "LibWigets", of the DB section ).
• {DB_TBL}_io -- Table with working properties of widgets in this library and embedded widgets of the container widgets (structure "LibWidgetIO", of the DB section ).
• {DB_TBL}_uio -- Table with user's properties of widgets of this library and embedded widgets of the container widgets (structure "LibWidgetUserIO", of theDB section ).
• {DB_TBL}_incl -- Table with the list of embedded widgets in the widgets-containers of the library (structure "LibWidgetIncl", of the DB section ).
• {DB_TBL}_mime -- Table with the resources of the library and its widgets (structure "LibWidgetMime", of the DB section ).

To control the widget library and the individual widgets the configuration scripts were written on the language of control interface of ~OpenSCADA. Currently, these scripts are designed to perform only the functions of the central configuration of the VCA engine elements, but later there is plans to expand them and give them the functions of processing requests to the data model from the presentation(visualization) modules to organize the "weak links" between the "Data model" and "Prepresentation(visualization)".

The basis of virtually all elements of the engine has become an object of the abstract visualization element (VCA::Widget). At its, abstract, level the object has the following properties:

• "Using" inheritance - the mechanism of inheritance of individual properties of another instance of the object. It is used for organizing the mechanism of secondary using, redefinition and definition of the elements of visualization.
• Storage the properties(attributes) of widgets with the mechanisms of "using" inheritance of the values. The mechanism of "using" inheritance does the inheritance of the properties' values from the root element and to the top one, with the ability to redefine the values at each level. In this case, the database stores only the values of modified properties.
• Support of the container mode. In this mode, the widget may include other(child) widgets, like the widget library contains widgets. It is used in library widgets that inherit properties of the primitive-container, such as the frame primitive "Box". Also, this property will be used in the session of the project to build the hierarchical tree of widgets(primitives) in the formation of the final image of frames' visualization.
• Support the mode of simple connection. This mode is used for the embedded widgets of the library. The feature of this mode is that it does not inherit the properties of the container, and therefore can not directly contain the embedded widgets (Figure 4.10.2).
• Contains the procedure of the internal logic of the widget on one of the languages of the OpenSCADA system. The logic of this procedure can be used to organize the interaction of embedded widgets and container with each other to form the desired behavior.
• Providing of access to the resources, mime-data, taking into account the hierarchy of "using" inheritance.

For the presentation of thelibrary of widgets the class (VCA::WdgLib) is implemented. Its main function is to maintain the library of widgets, storage and loading them from the database, providing an access to the resources(Mime-data), as well as the separation of access.

Especially for the inclusion in the library of widgets the class of the library widget (VCA::LWidget) was created, which is based on an abstract widget's class (VCA::Widget) and provides additional functions: storing the widget data in tables of the library, the redefinition of the access to the resources on the table with the mime-data of the library and storage of the embedded container widget (VCA::CWidget).

In its turn, the class of the container widget (VCA::CWidget) provides the following functions: the storage of the container widget's data in the tables of the library, the redefinition of the access to the resources on the table with the mime-data of the library and the forced mode of the simple link for all container widgets.

On the basis of the library widget's class (VCA::LWidget) it was formed an abstract class of the terminal widget (VCA::PrWidget). And on its basis the implementations of primitives of basic widgets are formed, which form the library of basic widgets, which is created by the module at initialization. The values of the properties of the basic widgets, also can be stored in the database (tables of the widget's library), forming the desired templates. In addition, the basic library of primitives can improved by the extended primitives from the modules of the presentation(visualization) interfaces, for which the basic ones are not enough. But in this case it must be taken into account that such action - the way to an incompatibility between the modules of the presentation(visualization) interfaces!

Implementation of basic functions of the development framework of the user interface in the presentation(visualization) module UI.Vision

Interface of the user interfaces' development of the module is based on MDI (Multi Document Interface) interface. This approach allows you to simultaneously edit multiple frames of various sizes. The following arrangements for managing the development are used: the toolbar, menu and context menu. Most actions are duplicated in the different mechanisms, so you can quickly find the tool by the preferred method. Navigation interfaces are implemented by the attachable windows. The configuration of toolbars and attachable windows is saved on exit and restored at startup that lets you to configure an interface for yourself.

One of the elements of the user interface, implemented as the attachable window is the browser of the widget's library. With the browser you can quickly find the widget or the library and do the necessary operations on them. The following operations are implemented: addition, deleting, configuration of widgets and libraries, as well as visual editing of the widget.

For easy management of the properties of widgets/frames the inspector of attributes(properties) of widgets is implemented. Inspector of the attributes is implemented as the attachable window, which is activated when you select the frame or widget. Window of the inspector of attributes can be conveniently positioned by attaching it to one of the sides of working window. Inspector of attributes supports the group configuration of several widgets, as well as the grouping of similar properties.

For visual editing of the frames the primary support for editing of widgets and frames is implemented. In the editor the following functions are implemented:

• selection of widget and group of widgets on the frame;
• moving of widgets through the frame;
• resizing the selected widgets on the frame;
• editing the properties of the selected widgets;
• alignment and management of the levels of visualization of the selected widgets.

Example of the development window is shown in Fig. 6.1.1. At the figure you can see: the toolbar, navigator of widgets, inspector of attributes, editing window of the frame and status bar.

Fig.6.1.1 Development window of the UI.Vision module

To configure the widgets' objects and their libraries the two dialogues are implemented: the dialogue of the widget's configuration (Fig.6.1.2) and the configuration dialog of the widget's library configuration (Fig.6.1.3). The library configuration dialog allows to set the basic properties of the library and put the mime-data in the database for subsequent using in the widgets of the library. Widget's configuration dialog allows you to set: the basic properties of the widget. individually to set the values of attributes and configure the internal procedure for computing the widget with additional(user's) properties.

Fig.6.1.2 Dialog of the widget's library configuration.

Fig.6.1.3 Dialog of the widget's configuration.

6.2 Visualization interface projects -- Done

The objectives of this stage are:

• Implementations of the projects of the visualization interfaces at the level of VCA data model in the UI.VCAEngine module:
  • The development of link tools of the frame: local links inside frames, external links on the parameters of the data acquisition subsystem of OpenSCADA and on the actions of the interface for events.
  • Development of the pages' tree of the project and their interactions.
• Implementation of the projects of the visualization interfaces in the presentation(visualization) module UI.Vision(QT):
  • Formation of the navigator on the projects.
  • Formation of the configuration dialog of the project's page;
  • Implementing of the support for the possibility of direct graphical formation of the page on the project's level with the possibility of visual linkage (including the logic links).

At this stage, it was added the mechanism of VCA projects formation by means of the building of the visualization pages in the hierarchical form, which corresponds to the logical links in the final VCA interface. During the implementation of this stage, the work was begun on the adaptation of the visualization module Vision to use the control interface of OpenSCADA instead of direct-strong links. These works have led to significant unification of the various dialogues, control structures and user interface in general.

At this stage it is implemented:

• Links mechanism. Just on the parameters of data sources! Internal links will be implemented in subsequent stages.
• Inspector of the links of Vision module, using the scenarios of the control interface of OpenSCADA.
• Mechanism of formation of the pages' tree based on the terms: page-template and page-container. This mechanism allows you to simply describe the relationship between the pages of most known types of user interface with an effective addressing and links to pages either individually or by template.
• Navigator through the project's tree, as on the scripting language of control interface and in the Vision module, using the same scenarios of the control interface.
• Dialogue of the project's and project page's configuration. In fact, the configuration dialogs of the project's and the library's elements are combined and also the transfer to the weak links of the control interface of OpenSCADA is done.
• Thanks to the unification of the interface of access to the elements of the library and the project, the possibility of direct formation of pages on the project's level is implemented.

6.3 Sessions of the project's execution -- Done

The objectives of this stage is:

• The implementation of the execution sessions of the projects at the level of data model of the VCA in the UI.VCAEngine module:
  • Formation of the hierarchical tree of widgets of the final visualization based on the project for which the session opens.
  • Formation of the values' frames for the procedures of final visualization widgets' calculation.
  • Processing the links on the parameters of the data sources of OpenSCADA.
  • Implementation of the hierarchical calculation of the procedures and updating the widgets links.
  • The formation of the mechanism of transmission and processing of events in the hierarchical tree.
• Implementation of visualization of the projects' sessions in the visualization module UI.Vision (QT) as the full fledged user interface with elements of visualization of dynamics, history and control:
  • Formation of the execution window of the project (RunTime).
  • Visualization of the project's frames in the "RunTime" mode with periodic update of the content.
  • Implementation of the transmission and processing of events.
  • The implementation of the mechanism of the switching/opening/substitution/navigation through the pages of the project taking into account the scenarios(scripts) of processing.

At this stage it was added the mechanism of the project's execution in the sessions of the data model of the VCAEngine module, as well as visualization of the project's session, the "RunTime" mode in the visualization module on the QT library Vision with the elements of the data update and interaction with the user.

Formation of the hierarchical final visualization widgets' tree based on the project for which the session is opened.

In accordance with Fig.4.10.1 and Fig.4.10.2 the objects of the project's session are inherited from the abstract object Widget and use the appropriate objects of the project. Thus, the session (Session) uses the project (Project) and forms the expanded tree on the basis of it. The project's page Page is directly used by the session's page SessPage. The remaining objects (SessWdg) are shown in accordance with the hierarchy of page's elements (Fig.4.10.2).

In addition to the standard properties of the abstract widget (Widget) the elements of the page and pages of session get the properties of storage of frame of values of the computational procedure, calculation of procedures and events' processing mechanism. Pages of the session, in addition to all, contain the container of following by the hierarchy pages. The session is calculated with the specified periodicity and in the following sequence:

• "Top level page" -> "Lower level page "
• "Lower level widget" -> "Top level widget"

This policy allows you to pass the page in accordance with the hierarchy, and events in the widgets to rise to the top in one iteration.

The session includes the support for the special properties of the pages:

On the basis of these properties the following types of pages are implemented:

Providing the values' frames for the final visualization widgets' calculation procedures.

In the section above, we have already noted that the widget of the session contains the frame of values of the calculation procedures. This image is initiated and is used in the case of presence of the calculation procedure. At the time of the initialization the list of parameters of procedure is created and the compilation of the procedures with these parameters is done in the module that implements the selected programming language and that id encoded with the full name of the widget. The compiled function is connected to frame the values of calculation procedures. Next, the calculation is done with the periodicity of the session.

Calculation and processing of the widget as a whole is done in the following order:

• the events, available at the time of calculation, are selected from the attribute "event" of the widget;
• events are loaded into the parameter "event" of the calculation frame;
• the values of input links are loaded into the frame of calculation;
• the values of special variables are loaded in the calculation frame (f_frq, f_start and f_stop);
• the values of selected parameters of the widget are loaded into the calculation frame;
• calculation;
• upload of the calculation frame's values to the selected parameters of the widget;
• upload of the calculation frame's values on the outgoing links;
• upload the event from the parameter "event" of the calculation frame;
• Events' processing and transfer the not processed ones to a higher level.

Processing the links on the data sources of OpenSCADA.

At the execution of the widget of the session it is necessary to make the links' processing. At the moment the connection on the links is made at the time of calculation, which is not a quick operation. Implementation of links processing will be reviewed and optimized in the future.

The support for the following types of links is provided:

• Constant value ("V"). The variable to determine at the time of the configuration on the page in the project.
• The attribute of the parameter of subsystem "Data acquisition" ("P"). The mechanism of access to the values of the parameter of subsystem "Data acquisition" of the OpenSCADA system.
• Attributes of the embedded widget ("W"). Internal direct link between the embedded widgets.

Currently the first two types of links are implemented. The last will be implemented together with the implementation of the basic widget "Link".

Formation of the window of the project execution (RunTime).

On the side of visualization (Vision module) to visualize the process of execution of the project the VisRun object is implemented. At startup it sends the request to create and initialize the session. Further the request on the list of opened pages is made. Based on the information of the VisRun opened pages and their connections, the resulting interface is formed. Fig. 6.3 shows an example of classical SCADA interface with alarm objects, where the main window contains a page inside which is replaced by pressing the buttons of alarm objects and paging.

Fig.6.3 The visualization of the project's execution window. The "RunTime" mode.

Visualization of the project's frames in the "RunTime" mode with periodic update of the content.

The update of the contents of the opened pages of the visualization interface with the periodicity of the execution of the project's session is implemented. In the update process it is done:
- request of the list of opened pages in the model and checking consistency of the really opened pages to this list;
- requests of the modified data on each page and widget;
- update the content of the pages and their widgets in accordance with the received modified data.

By closing the "RunTime" window the closing of the project's session in the data model is made. It will be implemented the opportunity to connect to the earlier opened session and disconnect from the session without closing it.

The mechanism of the request of the only modified data is based on absolute counter of the session's execution. When you make real changes in the attributes of widgets the remembering of the value of this counter is made, which allows us to identify the modified attributes. This approach allows to increase productivity and reduce the load on the traffic in case of access to the model through the network.

Realization of transfer and processing of events.

The visualizer of the ("RunTime") session, because of its direct contact with the user, collects various events. Some of the events are processed by the images of the basic widgets (Text, Box, Document, etc.), which can form other events. Another part is directly transfered to the data model, where they are processed.

To the data model events are transferred immediately upon their receiption, where they are collected in the attribute "event" of the widget until the next iteration of the session's execution. Further, in the process of data session's calculation, the events are extracted from the "event" attribute and are processed in the procedure of the widget or in accordance with the script(scenario) in the "evProc" attribute. The events which are not processed rise to the higher widget of the model.

The implementation of the mechanism of the switching/opening/replacement/navigation through the pages of the project taking into account the processing scenarios(scripts).

Switching, opening, replacement and navigation through the pages is based on processing the events on the scenario(script) in the attribute of the active widget "evProc". Script of this attribute is written in the form of the list of commands with the syntax of: <event>:<srcWdg>:<com>:<prm>
where:

The following commands are implemented:

Special characters of the template is interpreted as follows:

To understand the mechanism of the templates lets give some real examples:

In conjunction with the above described mechanism on the side of visualization (RunTime) the logic that controls the way of the opening the pages is built. The logic is based on the following attributes of the basic element "Box":

The logic of determining the opening of the pages works as follows:

• if the page has the group "main" or coincides with the group of the page in the main window, or there is no page in the main window, then open the page in the main window;
• if the page has the group which coincides with the group of one of the containers of the current page, then open in this container;
• if the source of the opening of page coincides with the current page, then open it as an additional window over the current page;
• transfer the call of the request of the opening to the additional windows with the processing at each of the first three items;
• if no one from related windows does not open the new page, then open it as the related window of the main window.

Combination of all these mechanisms now allows you to build complex, multi-level and multi-window user interfaces.

6.4 Designing and implementing the visualization primitives-- Implementation

At this stage it is planned to implement the data models and images of the Vision visualizer for all the basic elements: "ElFigure", "FormEl", "Text", "Media", "Diagram", "Protocol", "Document", "Function", "Box", "Link".

6.4.1 Elementary figure primitive (ElFigure)

Support of the following elementary figures is provided: lines, elliptical arcs, Bézier curves and fill of the enclosed space with the color and/or image. For the elementary figures the following operations are provided:

• creation/deleting of the figures;
• copying of the figure(s);
• moving and resizing of the figures by mouse and keyboard;
• possibility to connect the elementary figures to each other, getting more complex figures, for which all the properties of the source elementary figures are available;
• possibility of simultaneous movement of several figures;
• fill of the enclosed space with the color and/or image;
• generation of mouse key events at the time of the mouse-click on the filled spaces;
• scaling;
• rotation.

The general concept of creating and managing the basic figures.

The figures underlying this widget, containing the points (the start and end ones) that can be connected with the according points of other figures; and the points with the help of which the geometry of the figure can be changed.

It is possible to add the figure using the mouse:

1. Select the desired figure from the context menu.
2. Set with the left mouse-button start and end points (for line with the SHIFT key hold its orthogonal drawing is made).

The deleting of the figure(s) it is possible by pressing "Del", having selected figure(s).

The copying of the figure(s) it is possible by pressing keys "Ctrl"+"C", having selected figure(s).

Moving/resizing of the figure it is possible by using the mouse or keyboard:

1. Select the figure, by clicking on it with the left mouse button.
2. Drag (with the help of mouse or control keys) the figure or one of its control points in the desired location and release the mouse button (key).

It is possible to move several figures, selected by means of holding "Ctrl" and clicking on the desired figures (this option works when the button Connections (Connections) is disabled) or by mouse selection.

The connection of the figures with each other it is possible by the following way:

1. Press the Connections button.
2. Select one of the figures and move its start or end point to the desired start or end point of the other figure so that it will get to the appeared circle, release the left mouse button. Connected figures are moving as well as the individual, the general point is moved for all connected figures, to which it refers(priority is given to the arc, two arcs can't be connected directly with each other ).

To fill the enclosed space from the figures it is possible with the following way:

1. Press the Connections button.
2. Create the enclosed space.
3. Make the double-click of the left mouse button inside of it.

To delete the fill of the enclosed space it is possible from the context menu of the widget; by braking the enclosed space or by double-click of the left mouse button on the already existing filled space.

Rotation of the figure is made around the center of the widget.

Fig. 6.4.1 shows the part of the screen with a frame containing the elementary figures.

Fig.6.4.1 Realization of elementary figures in the Vision.

6.4.2 Primitive of the form element (FormEl)

Support of the form elements on the VCA frames is provided. The following form elements are included:

The following modes are realized: «Enable» and «Active», as well as transfer of changes and events to the data model of the VCA (engine).

Fig. 6.4.2 shows a part of the screen with the frame containing the above-listed elements of the form.

Fig.6.4.2. Realization of the form elements in the Vision.

6.4.3 Text primitive (Text)

Support of the text element with the following properties is provided:

• Font with the properties: type/class of the font, size, bold, italic, strikeout and underline.
• Text color.
• Text orientation.
• Automatic word wrap.
• Alignment of the text horizontally and vertically with all options..
• Displaying the background as the color and/or image.
• Display the border around the text, with the specified color, width and style.
• Formation of the text from the attributes of different types and properties.

Fig. 6.4.3 represents a part of the screen with the frame containing the text examples using various parameters.

Fig.6.4.3. Realization of the basic text element in the Vision.

6.4.4 Primitive of the displaying the media materials (Media)

Support of the element of the displaying of media materials with the following properties is provided:

• The indication of the source of media data (images or video material).
• View of the images of most well-known formats with the possibility of inscribing of it in the size of the widget.
• Playback of the simple animated images and video formats with the possibility to control the playback speed.
• Displaying of the the background as a color and/or image.
• Display the border around the text, with the specified color, width and style.
• Formation of the active areas and generating the events when they are activated.

Fig. 6.4.4 represents a part of the screen with the frame containing examples of viewing/playback of media data.

Fig.6.4.4. Realization of the basic element of the displaying of media materials in the Vision.

6.4.5 Primitive of the construction of diagrams/graphs (Diagram)

Support of the element of the construction of diagrams/graphs with the following properties is provided:

• Construction of graphs/trends:
  • Construction graph for: archive data, current data and the formation of an intermediate buffer for the display of the parameters without archive.
  • Construction of a single graphs with the value of the parameter on the ordinate axis, and the combined graphs of up to 10 parameters, with the percentage scale.
  • Ability to adapt the parameter's graph to the value, the regrowth of scale.
  • Wide range of scalability and adaptation of the horizontal scale, with automatic averaging at the server level and the primitive itself.
  • Ability to display the size grid and markers on the horizontal and vertical, with adaptation to the displaying range.
  • Support of the active mode, with the cursor and getting values under the cursor.

Fig. 6.4.5 represents a part of the screen with the frame containing examples of the trend-diagrams.

Fig.6.4.5. Realization of the basic element of a diagram-trend displaying in the Vision.

6.4.6 Primitive of the protocol formation (Protocol)

Support of the element of the formation of the protocol with the following properties is provided:

• Formation of the protocol from the archive of messages for the specified time and depth.
• Request of the data from the messages archivers.
• Selection of data from the archives by the level of importance and the category of messages template.
• Support the tracking mode for the appearance of messages in the archive of messages.

Fig. 6.4.6 represents a part of the screen with the frame containing an example of the protocol.

Fig.6.4.6. Realization of the basic element of a protocol displaying in the Vision.

6.4.7 Primitive of the box container (Box)

Support of the primitive of the container concurrently serves as the project pages is provided. This primitive is the only element-container, which may include links to frames from the library, thereby creating the user elements of desired configuration. Primitive implements the provided by the project properties. The properties of this primitive are:

6.7 The implementation of weak links between data model and presentation(visualization) -- Done

During this stage implementation it will be written the additional scripts of the control interface to cover the objectives of the organization of weak links between the model (VCAEngine) and visualizer (Vision). On the side of the visualizer (Vision) it will be complete transition to the weak links with the data model of VCA.

At this stage it was created the missing scripts of control interface and made the full translation of module visualization (Vision) on the weak links. As the result of the operation it was achieved the significant unification of the visualizer and enhance its stability. The question of productivity has remained opened and will be considered later.