Distributed Control & Automation Framework (DCAF)
DCAF Tag Editor Core Documentation
Overview
This package contains a collection of class implementations, libraries, and user interface VIs which enable interactive configuration of engines, modules, tags, and mappings within the Distributed Control and Automation Framework (DCAF). This core set of code enables the configuration ‘View’ for the standard editor as well as specific editor node classes.
Description
This package includes code that enables the configuration Views for systems, targets, and modules. These Views are configured with the Standard Configuration Editor. An engine configuration UI is included with each engine (such as the Standard Engine Module). Even still, the configuration editor provides the infrastructure to load, select, display, edit, and save configurations for modules within the system.
This infrastructure is built into the Standard Configuration editor that uses a queued message handler architecture.
UI events and the associated node IDs are enqueued into a message queue. For example, when the user selects a module in an engine, the “<node change>: User Event” fires, the event handler enqueues the “NodeDataChange” message with the node ID as part of the message.
The message processor loop processes that message and enqueues more messages as appropriate. One of those messages will load the class associated with that specific node ID and load the configuration and configuration editor/user interface/view for that node. Messages are implemented with the Asynchronous Message Communication (AMC) Library.
Here is a view of the DCAF Standard Configuration Editor:
Note: this specific screenshot was taken from the example project for temperature control which has been modified for Windows-only use.
In the tree on the left, you can find a hierarchical view of the system.
Each system configuration specifies targets. On each target, engines are each configured to implement some requirements of the application. Within each engine, modules are used to implement specific behaviors within the scope of the engine.
Core engine viewing nodes such as “Tags” and “Mappings” allow users to create tags to store current values for variables used by the application. Additionally, these tags are mapped to module inputs and outputs. More information about tags and mappings can be found in the DCAF Development Guide.
As you develop your own applications with DCAF and even develop custom modules with their own respective UIs, you may want to reference some of the shipping configuration VIs to see how these VIs interact with the configuration editor and how they process configuration data.
|
System Configuration |
PL Framework Configuration Tool.lvlib : Systems.lvclass : SystemsUI.vi |
|
<target> “PC” Each target type |
PL Target PC.lvclass : PCUI.vi |
|
Standard Engine (UI) Installed with engine |
Standard Engine Editor Node.lvclass : StandardEngineUI.vi |
|
Tags |
PL Framework Configuration Tool.lvlib : EngineTags.lvclass : EngineTagsUI.vi |
|
Mappings |
PL Framework Configuration Tool.lvlib : EngineMappings.lvclass : engine mappings UI.vi |
Other tools are installed with the Tag Editor Core module which are available within the Standard Configuration Editor:
Edit Search Plugin Paths: to modify folders where DCAF should search for plugins.
Deploy: to save the configuration file to the selected target.
Script Include VI: to script/rescript a VI that includes static calls to runtime objects that must be deployed to the target because they are used by the application. You must select both the includes VI and the target, and the utility scripts a simple VI with required dependencies as shown below.
Configuration of the Tags Node
A “Tags” node is automatically created when a new engine is instantiated in the Standard Configuration Editor. Exactly one Tags node will be present in each engine. Select the Tags node in the system tree to show the Tag configuration UI and data.
You can add tags one at a time, create many at once, and import them from file. Push the “+” to add a new tag; the following configuration UI will launch:
Each tag must have a unique name within that engine, a datatype, and a default value. Optionally, you can add a description for your tags.
Here is an example of the tags created for the Temperature Control Example (<LabVIEW>\examples\DCAF Examples\RT Temperature Controller).
Now, it is necessary to map these tags to channels in other modules.
Configuration of the Mappings Node
A “Mappings” view node is automatically created when a new engine is instantiated in the Standard Configuration Editor. Exactly one Mappings node will be present for each engine. Select a Mappings node in the system tree to show the mapping configuration UI and data.
To create meaningful mappings, you need to already have tags created and other modules (and their channels) defined. For the Temperature Control Example, mappings have been defined such that input channels write to tags and output channels read from tags. This direction is indicated in the “Dir” column. Each tag may have only one data source. Mappings are defined within the context of an engine; in this example, the UDP modules are communicating data to each other (between engines).
Note that in this example, the Standard Engine (UI) sets the following system inputs:
- Controller Parameters
- P
- I
- D
- Fan On?
- Setpoint
and displays the following system outputs on the same UI:
- Temperature
- Lamp Intensity
· Tags and mappings are defined to set and move data between each module.
The ‘Visualization’ tab allows you to view the channel-tag mappings per module. For the UI Reference Module:
For the UDP Module:
Software Requirements
- LabVIEW 2014 or newer
Limitations
- Tag datatypes are limited to
Installation
Tag Editor Core is automatically included with the installation of the DCAF Core package from VI Package Manager.
Support
Post issues on GitHub and ask questions below.
Visit Collaborating on the Development of DCAF to learn how to contribute your own improvements to this module directly.
