|
Technology > Features > Integration
Widgets and GUI Builder
A Widget is a special "sub-application" with a graphical user interface
(GUI) consisting of a number of graphical components, such as text fields,
charts, etc. Widgets are good for building custom forms, dynamic maps and
Human-Machine Interfaces (HMI). These forms and interfaces may be used
to control, configure and monitor different hardware devices or system
components. Widgets may grouped into a
dashboard.
Widget components are tied to server and device data using
data bindings. Bindings may also tie components together and define
different expression-based data conversion patterns. Bindings may be activated:
- During widget startup.
- Upon some server-side event, e.g. when new device data arrives.
- Upon widget component event, e.g. button click.
- Periodically.
Scripts written in Java may be combined into the widget template, in
case some data processing task cannot be performed using expressions.
Widgets may include a number of different components:
 Labels- Text and Password Fields
- Text Areas
- Buttons and Toggle Buttons
- Combo Boxes
- Lists
- Check Boxes and Radio Buttons
- Sliders and Spinners
- Progress Bars
- Tables
- Images
- Dynamic Vector Drawings
- Charts
- Dynamic Maps (roadmap/terrain/satellite)
- Gauges, Meters
These components may be grouped in various containers:
- Panels
- Tabbed Panels
- Split Panels
- Layered Panels
Containers support two layouts:
- Grid layout that auto-aligns components according to their size. It is especially good for building forms.
- Absolute layout with strictly defined component positions and sizes. This layout is useful for building SCADA-like custom screens, maps, plans etc.
Containers with different layouts may be combined within one widget to
build complex interfaces.
GUI Builder
Widgets are created in the GUI Builder, which is a part of AggreGate
Client. It’s a graphical editor for widgets. It doesn't require any
programming knowledge, and lets you easily:
- Add, move and resize components.
- Edit widget layout.
- Bind server data to widget components.
- Edit component properties and data bindings.
Widget may be launched at any time directly from the GUI Builder. Even in
such test mode, they may operate with real server and device data.
Dashboard
When AggreGate is used for monitoring electronic devices, it's often
important to be able to view their operational status and important
parameters in real-time. Moreover, it may be necessary to execute certain
operations quickly in response to changes in monitored data. This is what
custom widgets
are for. They may represent device state and also contain buttons and other
input controls, to allow interactive communication with a device.
The idea is to have the widgets constantly active when a system operator is
on duty. They should run automatically upon client start-up.
A dashboard is a group of widgets that are started automatically
(via Auto-Run) and placed in pre-defined positions to allow quick access to
system-critical parameters and functions.
Expression Language
AggreGate’s expression language is used:
Expressions are simple to use due to the automatic type conversion. In
addition to classic operators and literals, the expression
language has a large library of functions:
- String processing functions
- Number processing functions
- Date and time processing functions
- Tabular data processing functions
- And more
The Expression Builder helps create complex expressions without much coding.
Scripts
The integrated expression language helps with most everyday data processing
tasks. However, sometimes it’s just not enough. There comes a time when you
need the power of a full-scale programming language with loops, variable,
constant declarations etc. For this, AggreGate Server processes scripts
written in pure Java. It runs these scripts within the server’s Java Virtual
Machine (JVM), therefore allowing them to access all internal server data in
addition to the script's own input parameters.
Scripts may be called from expressions, thus making them accessible for:
Scripts are written in Java and thus may access all resources of the
machine AggreGate Server is running on, including:
- File system
- Network and serial I/O
- Console, logging, and even GUI
- Multithreaded processing
Logging
As with most server software, AggreGate Server's spares no effort when
it comes to logging. Everything can be logged, and logging configuration can
be changed at runtime without restarting the server.
Logging output may be sent to:
- Console
- Text file
- XML file
- Windows event log
- UNIX Syslog
- Database
- Remote network server
- E-mail messages
- Java Message Service (JMS)
- And many other destinations
Logging output is divided into more than one hundred categories (such as
database, device communications, GUI, etc.). Each category may be redirected
into a separate set of destinations. There are five logging levels:
Debug, Info, Warning, Error, and Fatal.
Each category can have a different level.
Multiple Time Zones Support
AggreGate is a distributed system. In a large installation, different
components may be deployed in several countries or even across several
continents. Thus, AggreGate Server, system operators, and managed devices may all
be located in different time zones. It is necessary to configure time zones
properly when setting up the system. Once this is done, timestamps will be
automatically converted during system operation.
 Server, user accounts, and device profiles have separate time zone settings.- If custom values are not specified, users and devices are assumed to be in the server's time zone.
- When the server synchronizes the time of hardware device controllers, it takes into account the time zone difference.
- When events are loaded from the device and stored in the server's event history, the event's internal time is converted from the device time zone to the server time zone.
- In any AggreGate Server's user interface, all timestamps are shown to the operator in his own time zone.
- By default, time zone values are taken from operating system settings.
Export And Import
AggreGate Server user interfaces are based on several standard
components. One of them is a generic tabular data editor, supporting export
and import operations. This lets users export and import virtually any data:
- Properties of system resources and hardware devices
- Historical events
- Query results
- Reports
Users may specify which data fields to export or import. When exporting,
you can also tweak the resulting file – for example, change the separators
used in CSV files.
Supported export and import formats:
- PDF (Adobe Acrobat)
- RTF (Rich Text Format)
- ODT (Open Office)
- HTML (Hypertext Markup Language)
- XLS (Microsoft Excel)
- CSV (Character Separated Values)
- XML (Extensible Markup Language)
- And more
Web Services
Web Services is a set of protocols for generic data exchange between
different systems. AggreGate Server supports Web Services technology for
integration with third-party software systems.
Communication is performed using the SOAP protocol, by sending XML-encoded
data over secure HTTP connections.
AggreGate Server’s Web Service allows total control of the server. It is possible
to stop/restart the server, manage users, register and configure connected
hardware devices, view device events and their status, etc. In other words,
AggreGate functionality can be completely integrated into an existing framework.
Java and .NET API's
AggreGate provides open-source Application Programming Interfaces (APIs)
for accessing AggreGate Server from Java and .NET environments. These APIs let you
remotely control, configure and monitor the server and all hardware devices within
a single installation from any Java or .NET application:
- Access server resources and connected devices;
- Modify server and device configuration;
- Execute server and device operations;
- Acquire server and device events;
- Connect to AggreGate Server in "device mode", i.e. write .NET/Java code that emulates or "implements" a hardware device connected to AggreGate.
Java-Based Architecture
AggreGate is based on Java. This means it runs on a wide range of hardware
platforms and operating systems. AggreGate Server may be installed on:
- Enterprise-grade servers
- Desktop PCs and laptops
In addition, AggreGate Client can also run on:
- Thin clients
- Java-enabled mobile devices with high-res displays
- Touch screens
Server fully supports headless console-only installations and operation on remote machines (via SSH, etc). Supported operating systems:
- Recent versions of Microsoft Windows (XP, Vista, Server 2003, Seven)
- Different Linux distributions
- Other Unices
- Mac OS
Database
AggreGate distribution includes an embedded database that is
ready to use immediately after installation, without any additional setup.
It is ideal for small installations with less than a hundred devices to
manage. Embedded database guarantees a very high performance when overall
size of all server data (properties, events,...) does not exceed several
hundred megabytes.
For medium and large installations, with thousands of devices, use an
external database management system. Supported database engines:
 MySQL- PostgreSQL
- Microsoft SQL
- Oracle
- Firebird
- Sybase
- Pointbase
- SAP DB
- Progress
- FrontBase
- Informix
- Ingres
- DB2
- And more (you can always ask us if your DMBS isn’t on this list)
Device Simulator
When deploying a large-scale distributed system, you always have to test system components, such as alerts, custom forms, and reports. However, at this stage hardware devices are either not connected to the server or not producing real data because they’re not doing the actual work they will do once the system goes online. The device simulator, or Virtual Device driver, has been designed to solve this problem by injecting test data into a system.
The simulator:
- Provides test data as read-write settings of different types, including complex tabular settings.
- Implements "device-side" operations for processing of any test data coming from the system.
- Generates test events.
- Simulates device communication and internal error conditions.
|
