Widgets

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 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
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:

In alert triggers, to raise an alert when a complex condition is satisfied.
In event filters, to select events that match several criteria.
In trackers, to monitor values involving several components.
In custom forms and Human-Machine Interfaces for binding server and device data values to user interface components.
For building queries on-the-fly.

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 LinkServer 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:

Alert triggering
Event filtering
Queries
Custom forms and HMI data processing
Preparing report source data

Scripts are written in Java and thus may access all resources of the machine LinkServer 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 LinkServer'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, LinkServer, 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 LinkServer 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 LinkServer 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-Service

Web Services is a set of protocols for generic data exchange between different systems. LinkServer supports a Web Services technology for integration with third-party ERP, CRM and other software systems. Communication is performed using the SOAP protocol, by sending XML-encoded data over secure HTTP connections.

LinkServer’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 LinkServer from Java and .NET environments. These APIs let you control, configure and monitor the LinkServer 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 LinkServer 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 LinkServer 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 LinkServer 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. LinkServer supports:

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)