Ignition Integration
The Ignition Integration is a module for Inductive Automation's Ignition SCADA that provides read/write integration for all Ignition Tags into Litmus Edge, allowing you the leverage the power of Litmus Edge Analytics, Digital Twins and Integrations.
- Verify you have an Ignition instance running version 8.1.20 or greater running on a device with support for Java 11.
- Verify you have a Litmus Edge instance running version 3.22.x or greater.
- Open network access between Litmus Edge and Ignition on set port (defaults to 4777).
- Download the .modl module file, either from the Ignition Module Showcase or Litmus Central.
- Open your Ignition Gateway with Admin or higher permissions.
- Navigate to Config->Modules->Install or Upgrade a Module...
- Select Choose File and select "Litmus-Edge-Ignition-Integration.modl" and press Install.
- Read and agree to the Litmus EULA.
The module should now be installed. Navigate to Config->Modules. There should now be a new header labeled Litmus Automation, Inc. with a module labeled Litmus Edge Ignition Integration.
Verify that the version listed matches the expected version. To read more about version see: Releases.
Must be done after Installing the Ignition Module.
- Open the Ignition gateway with the module installed with Admin or higher permissions.
- Navigate to Config->Litmus Edge Integration->Settings (if this page is not present, ensure that the module is correctly installed), opening the config panel.
- In the configuration panel, ensure the properties match those in the Ignition driver on your Litmus Edge instance. When you are done press Save Changes.
- After any setting change, restart the module by navigating to Config->Modules and pressing the restart button next to the module.
Any changes you make to the module confiugration will not apply until you restart the module.
- In your Litmus Edge instance, navigate to: Devicehub->Devices->Connect a Device.
- In the device creation window, select: Device Type->Ignition->Ignition Module.
- In the device creation window, configure the Device properties.
- Ensure that Enable TLS is set to disabled (complete TLS support is planned for the near future but is unsupported as of module version 2.0.3)
- Ensure that the Network Port you enter is open for both the Litmus Edge and Ignition instances. If you use the default value, 4777, you do not need to reconfigure the firewall in Litmus Edge.
- When all properties are correct, press Create Device.
Once both the device and the module are correctly configured, they should automatically connect - indicated by the Device appearing as Connected in Litmus Edge.
If the module fails to connect, verify the Module configuration and restart the module. Give it approximately 1 minute to reconnect.
Once connected, Ignition Tags can be added to the device using Hierarchical Browse. This can be done in either of the following ways:
- Navigate to Devicehub->Tags-> Add Tag -> Browse Tags and select the Ignition Device
- Navigate to Devicehub->Browse. Select the Ignition device and create a new browse session.
Once a tag is added, it can be read via the tag alias topic.
See Browse Tags for more details.
See Manage Tags for more additional configuration of added tags.
Currently, Tags must preserve the name that is auto-assigned to them during browsing which matches their Tag Path exactly (eg. [System]/Time/Timestamp). Changing this Tag name will cause the Litmus and Ignition Tags to be dissociated.
Components in hierarchical browse are either Folders or Items. Folders contain child elements, whilst Items produce data and have corresponding Tags.
The hierarchy generated when browsing along with the correspondence of Ignition Tag types to browsing elements is the following:
- root (folder)
- Tag Provider (folder)
- Folder (folder)
- Atomic Tag (item)
- Property (item)
- UDT Instance (folder)
- Atomic Tag (item)
- UDT Type (folder)
- Property (item)
The root element will always be present as the highest level element and will have all accessible Tag Providers as children.
Tags which have write enabled in the Ignition gateway can be written to from Litmus Edge using the write topic of the tag. Ensure the data is formatted correctly whilst writing, as conversion will be handled Ignition side.
See Use the Write Topic to Send Data to a PLC for more details.
Ignition allows users to create their own structures for bundling multiple types of data into a single tag, called a UDT. UDTs are broken down into a collection of individual tags when imported into Ignition. See the Browsing Hierarchy for more details.
Ignition Type | Litmus Edge Type | Conversion |
|---|---|---|
Boolean | Bool | |
Byte | Sbyte | |
Short | Int16 | |
Integer | Int32 | |
Long | Int64 | |
Float | Float32 | |
Double | Float64 | |
String | String | |
DateTime | Int64 | uses signed UNIX timestamp (seconds since 00:00 January 1st, 1970) |
Text | String | |
BooleanArray | BoolArray | |
ByteArray | SbyteArray | |
ShortArray | Int16Array | |
IntegerArray | Int32Array | |
LongArray | Int64Array | |
FloatArray | Float32Array | |
DoubleArray | Float64Array | |
StringArray | StringArray | |
DateTimeArray | Int64Array | uses signed UNIX timestamp (seconds since 00:00 Janurary 1st, 1970) |
BinaryData | ByteArray | |
Document | Dataset | see Document for exact structure |
Dataset | Dataset | see Dataset for exact structure |
Document data follows a key-value pair convention for associating elements to their values. Document elements have 3 fundamental types:
- Document PrimitivesIndividual values, can have Number, String, Boolean, or DateTime types. (ex. 63, "cat", -1.234)
- Document ArraysContain an array of Document Elements of any type with a fixed order. (ex. [123, {"pressure": 10.0, "temperature": 10}, "litmus"])
- DocumentsContain key-value pairs, with String only keys and Document Element values of any type (ex. {"pressure": 10.0, "temperature": 10})
Document payloads are converted to Dataset types, which can be interpreted as JSON payloads, with the following conversions:
Document Primitives - are represented by a simple JSON value.
Document Arrays - are converted to a JSON object with the following elements:
- isArray Boolean always set to true for arrays
- value JSON object with with indices as keys and values as elements
- ex. {"isArray": true, "value": {"0": 72.2, "1": 232.2, "2": -2}}}}
Documents - are converted to JSON objects with the following elements:
- isArray Boolean always set to false for documents (can be omitted during writing)
- value JSON object with the payload of the document
- ex. {"isArray": false, "value": {"temperature": 10.0, "pressure": 10}}
An Ignition dataset type is a table with a fixed amount of columns and rows. Each column has a fixed type and name.
When a Dataset is read into Litmus Edge it is converted to a JSON payload with the following structure:
- Each Column is Represented by a JSON object with the following elements:
- name String set to the name of the column
- type String representation of the datatype of the column (eg. Integer). See Supported Tags for a list of the Ignition type names
- Note - Color types are converted to strings and are represented by the type "Object"
- data JSON object of the columns which each key corresponding to the row of the entry
- ex. {"data": {"0": 10.2, "1": 83.2 ...}}
- The Dataset is represented by a JSON object with keys corresponding to the index of each column.
- ex. {"0": {"name": "Temperatures", "type": "Float", "data": {"0": 10.2, "1": -2.3, "2": 56.7}}}
- Added read/write support for Document and Dataset types.
- Automatic reconnecting of Ignition module to Litmus Edge DeviceHub after temporary device outage.
- Graceful recovery of module upon Ignition gateway interruption.