One issue that arises with this workflow is that Ignition does not always immediately detect file changes made outside the Designer. After checking out a branch, merging changes, or pulling updates, the gateway will still need a manual file scan from the Gateway before the latest project or configuration files are reflected.

To make development workflows smoother for our projects at DMC, we created a script that uses the Ignition 8.3 Gateway API endpoints to trigger project and configuration file scans. By integrating this script into Git hooks, file scans can run automatically after branch checkouts or merges, eliminating the need to manually navigate to the Gateway webpage and trigger them each time (fig1 and fig2). Additionally, developers can manually run the script from Bash or the command line to trigger file scans on demand.

In this blog, we have provided a sample script and .env file, and we will walk you through the steps to set this up.

Why This Step Matters

There are a variety of reasons why automating this step is both important and beneficial. This automation reduces friction in the development workflow, reducing some of the common sources of errors and delays while improving team-wide consistency and clarity. By using Git hooks to automate file syncing in Ignition, developers avoid repeated trips to the Gateway UI and reduce mental load.

By adding automated file scans into the development workflow, teams can make Ignition 8.3 development feel more like regular software development, where Git-based practices like branching, merging, and pull requests fit naturally into SCADA projects.

Set Up Gateway API Key

In order to access the API endpoint, we need to set up an API key in the Gateway. Follow Ignition’s manual for this.

By default, Ignition requires API keys to be used over secure HTTPS connections. Since this script commonly runs against local development Gateways using standard HTTP, the Require secure connections for API Keys setting must be disabled for the requests to succeed.

Make sure to copy the ENTIRE api key. We will add it to the .env file in the next section.

Repo and Environment Variables Set Up

Copy the example script (included in the section below) into your desired location in your repo. For example, in this repo, we have put it at the following location and called it gateway_scan.py.

Path: ignition-docker-8-3\scripts\gateway_scan

Next, add the following variables to your .env file:

GATEWAY_IP= (your gateway’s IP address)
HTTP_PORT = (your gateway’s port)
GATEWAY_API_TOKEN=(your generated API token for the gateway)

The example script looks for these variables; if they are already in your .env and are named differently, open the example script and do a find-and-replace to update the variable names.

Git Hook Set Up

Git hooks let us automatically run scripts when certain Git actions occur. For this workflow, we typically set up Git hooks to run the gateway_scan.py script after branch checkouts and merges.

This means that when a developer switches branches, pulls changes, or merges updates, the Gateway file scan can run automatically without having to open the Gateway webpage and manually trigger it.

To set this up, create two files in the .git/hooks folder:

.git/hooks/post-checkout
.git/hooks/post-merge

Paste the following code into both files:

#!/bin/sh

# Move to the root of the git repository
cd "$(git rev-parse --show-toplevel)" || exit 1

# Run file scan script
py scripts/gateway_scan/gateway_scan.py

#!/bin/sh

# Move to the root of the git repository
cd "$(git rev-parse --show-toplevel)" || exit 1

# Run file scan script
py scripts/gateway_scan/gateway_scan.py

The post-checkout hook runs after switching branches. The post-merge hook runs after a merge, which also commonly happens when pulling new changes from the remote repository.

The first command moves the terminal to the root of the Git repository. This helps ensure the script runs from the correct location, even if Git triggers the hook from within the repository.

The second command runs the Gateway scan script:

py scripts/gateway_scan/gateway_scan.py

Developers can also run this command manually from Bash or the command line whenever they want to trigger a Gateway file scan on demand.

If the repository contains multiple gateways you want to automatically file scan for, add a separate set of environment variables for each gateway in the .env file, create an API key for each gateway, and then update the gateway_scan.py script following the comments, so the script knows which gateways to scan.

Example Script & env. File

#------------------Gateway Scan Trigger Script Example------------------
"""
Run script to trigger file scans for gateways.
"""
import os
from pathlib import Path
from urllib import error, request

REQUEST_TIMEOUT_SECONDS = 5

print("Syncing Ignition Gateway...", flush=True)


def load_env_file(env_path):
	"""
	Load simple KEY=value pairs from a .env file without third-party dependencies.
	"""
	if not env_path.exists():
		return

	for line in env_path.read_text(encoding="utf-8").splitlines():
		line = line.strip()

		if not line or line.startswith("#") or "=" not in line:
			continue

		key, value = line.split("=", 1)
		os.environ.setdefault(key.strip(), value.strip().strip("\"'"))


# Read in .env file
load_env_file(Path(__file__).resolve().parents[2] / ".env")

# Grab environment variables
# TODO: VERIFY YOUR .ENV FILE HAS THESE VARIABLES SET CORRECTLY
# CREATE ADDITIONAL ENVIRONMENT VARIABLES FOR ADDITIONAL GATEWAYS IF NEEDED
# BY COPYING THE FOLLOWING FORMAT
GATEWAY_PORT = os.getenv("HTTP_PORT_IGN")
GATEWAY_IP = os.getenv("GATEWAY_IP")
GATEWAY_API_TOKEN = os.getenv("GATEWAY_API_TOKEN")

# TODO: ADD ADDITIONAL GATEWAYS HERE IF NEEDED!
gateways = {
	"Ignition": {"ip": GATEWAY_IP, "port": GATEWAY_PORT, "token": GATEWAY_API_TOKEN}
	# Additional gateways can be added here in the same format
}

actions = ["projects", "config"]

def post_scan_request(url, headers):
	"""
	Post a gateway scan request and return the HTTP status code.
	"""
	req = request.Request(url, headers=headers, method="POST")

	with request.urlopen(req, timeout=REQUEST_TIMEOUT_SECONDS) as response:
		return response.status


def trigger_scans():
	"""
	Trigger scans on the specified gateways.
	"""
	for name, config in gateways.items():
		ip = config["ip"]
		token = config["token"]
		port = config["port"]

		if not ip or not token or not port:
			var_name = "ip address" if not ip else "API token" if not token else "Port"
			print(f"Skipping {name}: Missing environment variable '{var_name}'.")
			continue

		headers = {
			"X-Ignition-API-Token": f"{token}"
		}

		for action in actions:
			# Ignition uses the final path segment to choose the scan type
			url = f""

			try:
				status_code = post_scan_request(url, headers)

				if status_code == 200:
					print(f"Success: File Scan {name} {action}")
				else:
					print(f"Failed: File Scan {name} {action} (Status: {status_code})")
			except TimeoutError:
				print(f"Timeout: {name} took too long to respond.")
			except error.HTTPError as err:
				print(f"Failed: File Scan {name} {action} (Status: {err.code})")
			except error.URLError as err:
				print(f"Connection Error: Could not reach {name} at {ip}. ({err.reason})")


if __name__ == "__main__":
	trigger_scans()

# ---------------------.env file example for one gateway--------------------
# HTTP_PORT_IGN= "your gateway's port"
# GATEWAY_IP= "your gateway's IP address"
# GATEWAY_API_TOKEN= "your gateway's API token"

#------------------Gateway Scan Trigger Script Example------------------
"""
Run script to trigger file scans for gateways.
"""
import os
from pathlib import Path
from urllib import error, request

REQUEST_TIMEOUT_SECONDS = 5

print("Syncing Ignition Gateway...", flush=True)


def load_env_file(env_path):
	"""
	Load simple KEY=value pairs from a .env file without third-party dependencies.
	"""
	if not env_path.exists():
		return

	for line in env_path.read_text(encoding="utf-8").splitlines():
		line = line.strip()

		if not line or line.startswith("#") or "=" not in line:
			continue

		key, value = line.split("=", 1)
		os.environ.setdefault(key.strip(), value.strip().strip("\"'"))


# Read in .env file
load_env_file(Path(__file__).resolve().parents[2] / ".env")

# Grab environment variables
# TODO: VERIFY YOUR .ENV FILE HAS THESE VARIABLES SET CORRECTLY
# CREATE ADDITIONAL ENVIRONMENT VARIABLES FOR ADDITIONAL GATEWAYS IF NEEDED
# BY COPYING THE FOLLOWING FORMAT
GATEWAY_PORT = os.getenv("HTTP_PORT_IGN")
GATEWAY_IP = os.getenv("GATEWAY_IP")
GATEWAY_API_TOKEN = os.getenv("GATEWAY_API_TOKEN")

# TODO: ADD ADDITIONAL GATEWAYS HERE IF NEEDED!
gateways = {
	"Ignition": {"ip": GATEWAY_IP, "port": GATEWAY_PORT, "token": GATEWAY_API_TOKEN}
	# Additional gateways can be added here in the same format
}

actions = ["projects", "config"]

def post_scan_request(url, headers):
	"""
	Post a gateway scan request and return the HTTP status code.
	"""
	req = request.Request(url, headers=headers, method="POST")

	with request.urlopen(req, timeout=REQUEST_TIMEOUT_SECONDS) as response:
		return response.status


def trigger_scans():
	"""
	Trigger scans on the specified gateways.
	"""
	for name, config in gateways.items():
		ip = config["ip"]
		token = config["token"]
		port = config["port"]

		if not ip or not token or not port:
			var_name = "ip address" if not ip else "API token" if not token else "Port"
			print(f"Skipping {name}: Missing environment variable '{var_name}'.")
			continue

		headers = {
			"X-Ignition-API-Token": f"{token}"
		}

		for action in actions:
			# Ignition uses the final path segment to choose the scan type
			url = f"http://{ip}:{port}/data/api/v1/scan/{action}"

			try:
				status_code = post_scan_request(url, headers)

				if status_code == 200:
					print(f"Success: File Scan {name} {action}")
				else:
					print(f"Failed: File Scan {name} {action} (Status: {status_code})")
			except TimeoutError:
				print(f"Timeout: {name} took too long to respond.")
			except error.HTTPError as err:
				print(f"Failed: File Scan {name} {action} (Status: {err.code})")
			except error.URLError as err:
				print(f"Connection Error: Could not reach {name} at {ip}. ({err.reason})")


if __name__ == "__main__":
	trigger_scans()

# ---------------------.env file example for one gateway--------------------
# HTTP_PORT_IGN= "your gateway's port"
# GATEWAY_IP= "your gateway's IP address"
# GATEWAY_API_TOKEN= "your gateway's API token"

Conclusion

Automating file syncs in Ignition 8.3 is a simple configuration change that can deliver meaningful improvements to your development workflow. By reducing manual steps and ensuring the Gateway always reflects the latest project state, teams can work more efficiently and with greater confidence. For engineers using Git to manage their Ignition projects, this approach unlocks the full benefits of modern version control while keeping SCADA development reliable and consistent.

The post Triggering Gateway File Syncs for Ignition 8.3 Using Git Hooks appeared first on DMC, Inc..

NetLogic is C# code that is linked to Optix. Optix can call methods with parameters, set private C# variables, and has numerous C# Libraries integrated by default to assist with passing data between Optix and your C# code. Optix also allows you to link the monitoring of C# code to an Optix runtime instance.

Linking Variables

When creating NetLogic, you can define variables that interface with the C# code, and can be both written to and read from said C# code. You can also define variable categories to assist with organization.

• First, Variables are added onto the NetLogic object in Optix.

An example of variables attached to a NetLogic object

These variables can be referenced in the C# logic by utilizing the “GetVariable” method on our LogicObject.

• For any variables at the top-most level, simply call: LogicObject.GetVariable(“YourVariable”).
• For nested variables (such as variables under “Table” in the example above), define a new IUAVariable for the nested name (Tables in this case), and then reference the individual elements of that new variable.

private void ParametersSetup()

{
	DB_SERVER_IP = LogicObject.GetVariable("Server IP").Value;
	DB_SERVER_PORT = uint.Parse(LogicObject.GetVariable("Server port").Value);
	SERVICE_NAME = LogicObject.GetVariable("Service name").Value;
	DB_USERNAME = LogicObject.GetVariable("Username").Value;
	DB_PASSWORD = LogicObject.GetVariable("Password").Value;
	DB_QUERIES_FEEDBACK = LogicObject.GetVariable("Queries feedback");
	TABLES = LogicObject.GetVariable("Tables");

	TABLE_DESTINATION = TABLES.GetVariable("Destination").Value;
	TABLE_DISTANCE = TABLES.GetVariable("Distance").Value;
	TABLE_LOCATIONCHANGE = TABLES.GetVariable("LocationChange").Value;
	TABLE_EQUIPMENTSTATUS = TABLES.GetVariable("EquipmentStatus").Value;
	NUMBER_OF_DEVICES = LogicObject.GetVariable("Number of devices").Value;
	NUMBER_OF_EQUIPMENT_AREAS = LogicObject.GetVariable("Number of equipment areas").Value;
	CONNECTIONSTRING = $"Data Source=(DESCRIPTION=(ADDRESS_LIST=(ADDRESS=(PROTOCOL=TCP)(HOST={DB_SERVER_IP})(PORT={(int)DB_SERVER_PORT})))(CONNECT_DATA=(SERVER=DEDICATED)(SERVICE_NAME={SERVICE_NAME})));User Id={DB_USERNAME};Password={DB_PASSWORD};";
}

private void ParametersSetup()

{
	DB_SERVER_IP = LogicObject.GetVariable("Server IP").Value;
	DB_SERVER_PORT = uint.Parse(LogicObject.GetVariable("Server port").Value);
	SERVICE_NAME = LogicObject.GetVariable("Service name").Value;
	DB_USERNAME = LogicObject.GetVariable("Username").Value;
	DB_PASSWORD = LogicObject.GetVariable("Password").Value;
	DB_QUERIES_FEEDBACK = LogicObject.GetVariable("Queries feedback");
	TABLES = LogicObject.GetVariable("Tables");

	TABLE_DESTINATION = TABLES.GetVariable("Destination").Value;
	TABLE_DISTANCE = TABLES.GetVariable("Distance").Value;
	TABLE_LOCATIONCHANGE = TABLES.GetVariable("LocationChange").Value;
	TABLE_EQUIPMENTSTATUS = TABLES.GetVariable("EquipmentStatus").Value;
	NUMBER_OF_DEVICES = LogicObject.GetVariable("Number of devices").Value;
	NUMBER_OF_EQUIPMENT_AREAS = LogicObject.GetVariable("Number of equipment areas").Value;
	CONNECTIONSTRING = $"Data Source=(DESCRIPTION=(ADDRESS_LIST=(ADDRESS=(PROTOCOL=TCP)(HOST={DB_SERVER_IP})(PORT={(int)DB_SERVER_PORT})))(CONNECT_DATA=(SERVER=DEDICATED)(SERVICE_NAME={SERVICE_NAME})));User Id={DB_USERNAME};Password={DB_PASSWORD};";
}

private IUAVariable DB_QUERIES_FEEDBACK;
private string DB_SERVER_IP;
private uint DB_SERVER_PORT;
private string SERVICE_NAME;
private string DB_USERNAME;
private string DB_PASSWORD;
public IUAVariable TABLES;
private string TABLE_DESTINATION;
private string TABLE_DISTANCE;
private string TABLE_LOCATIONCHANGE;
private string TABLE_EQUIPMENTSTATUS;
private Int32 NUMBER_OF_DEVICES;
private Int32 NUMBER_OF_EQUIPMENT_AREAS;

private IUAVariable DB_QUERIES_FEEDBACK;
private string DB_SERVER_IP;
private uint DB_SERVER_PORT;
private string SERVICE_NAME;
private string DB_USERNAME;
private string DB_PASSWORD;
public IUAVariable TABLES;
private string TABLE_DESTINATION;
private string TABLE_DISTANCE;
private string TABLE_LOCATIONCHANGE;
private string TABLE_EQUIPMENTSTATUS;
private Int32 NUMBER_OF_DEVICES;
private Int32 NUMBER_OF_EQUIPMENT_AREAS;

Calling Methods

C# Methods can be called directly from Optix when the [ExportMethod] Line is added above said method. Any parameters associated with the Method will also be exposed, allowing you to set them dynamically from Optix, using a MethodInvocation or by linking them to events.

An example method invocation that shows all the [ExportMethod] methods from the Netlogic C# code

[ExportMethod]

public void SelectAllDevicesDestination()

{

…

[ExportMethod]

public void SelectAllDevicesDestination()

{

…

Monitoring Code

When NetLogic is created, Optix automatically configures the codespace (if utilizing VSCode) to attach to the Optix runtime instance, allowing you to monitor your C# card while the Optix application is running.

Visual Code is attached to the Optix Runtime when monitoring

Logging and Error Handling

Optix has a C# library for logging code that should be utilized, as it will output to the console in FT Optix Studio, as well as to the log file for the Optix application.

catch (System.Exception ex)
{
	Log.Error(MethodBase.GetCurrentMethod().Name, ex.Message);
}

catch (System.Exception ex)
{
	Log.Error(MethodBase.GetCurrentMethod().Name, ex.Message);
}

The location of Optix log files for an emulated project

Read the Other Articles in this Series

• FactoryTalk Optix Series 1 – Getting Started with FactoryTalk Optix
• FactoryTalk Optix Series 2 – Variables, Attributes, Dynamic Links, and Converters

The post FactoryTalk Optix Series 3 – NetLogic Overview and Examples appeared first on DMC, Inc..

Variables, Attributes, Dynamic Links, and converters are the building blocks of Optix UI design. Each variable has a number of attributes associated with it, and Dynamic links and Converters can be used to define a relationship between two or more variables/attributes.

A map of the relationships between Variables, Attributes, Dynamic Links, and Converters

Variables and Scope

Variable scope is influenced by the containers they are in. All variables with a given container (screen or panel) can access each other. Variables in nested panels have access to the variables in other nested panels and parent/children panels, and vice versa.

An example of variable scope extending to variables nested in other related panels

However, scope is limited when variables are not contained within a shared container, which happens most commonly with panels utilized in popups and panel loaders. However, the scope of panel loaders is unrestricted, so variables can be added to panel loaders and modified/updated anywhere in the Optix application, and the panels being loaded by said panel loader can then reference its variables to dynamically display information.

An example showing the limitations of scope when creation relationships between variables

To see an example of a panel loader utilizing variables to allow the Main UI to interact with individual panels being loaded by a panel loader, stay tuned for our upcoming Optix Series – Device Sidebar Example blog.

Attributes

Understanding attributes and their relationship to their parent variable is necessary to form complex Dynamic Links for UI functionality. Below is a list of the most common variable attributes.

To see an example of different attributes being used to create a clean, complex solution, stay tuned for our upcoming Optix Series – Device Sidebar Example blog, which utilizes NodeId, BrowseName, and DataType BrowseName attributes.

Converters

• Conditional Converter
  • Sets the output variable’s value based on a true/false evaluation of the input.

• Engineering Unit Converter
  • Scales the output linearly based on the input.

• Linear Converter
  • Scale the output based on a defined slope and intercept.

• Key-value Converter
  • Matches an output value to the input “Key”.

• Expression Evaluator
  • Evaluates an expression consisting of one or more input variables.
  • To see all of the valid operators that can be used in an expression, see Rockwell’s documentation.

• String Formatter
  • Outputs a string that can be defined using variables and various formatting options.

Dynamic Links

Dynamic links are defined relationships between two or more variables. Dynamic links can implement converters to create complex relationships and can be pointed at both variables and attributes.

Aliases

Aliases are a unique property type that allows you to specify the structure of a variable.  This is useful when creating panels that should be referencing a specific Data Types, such as a motor or valve Data Type. An alias allows you to reference all the elements of the defined Data Type, while still allowing the alias variable to be linked dynamically, allowing graphics to be updated in real time, such as being able to swap which motor a panel is pointing to.

An example of an alias to a Motor Data Type

An example use case of aliases is for a device sidebar that utilizes a panel loader to swap in faceplates panels for different types of devices. The panel loader would have a NodeId variable (Let’s call it “Device Tag”) that would be updated at runtime to point to a desired device tag. For each device type, one panel would be created with a tag alias with the “Kind” attribute bound to the UDT of said device and the “NodeID” attribute bound to the “Device Tag” Attribute on the panel loader. Typically, you cannot create property bindings between variables that are not within the same window or screen (or the same panel for panels that are not directly placed on windows or screens), but panel loaders can be referenced regardless of project scope, allowing us to make use of the “Device Tag” variable we attached to ours.

For an in-depth example, Stay tuned for our upcoming Optix Series – Device Sidebar Example blog.

Read the Other Articles in this Series

• FactoryTalk Optix Series 1 – Getting Started with FactoryTalk Optix
• FactoryTalk Optix Series 3 – NetLogic Overview and Examples

The post FactoryTalk Optix Series 2 – Variables, Attributes, Dynamic Links, and Converters appeared first on DMC, Inc..

This blog series covers the essentials to creating your own HMI and SCADA applications using Optix as well as some helpful examples for common applications.

Installation

FactoryTalk Optix Studio is installed via FactoryTalk Hub, and it is the IDE used to program Optix projects. You can either download the IDE application or utilize a web-based IDE if your license supports it.

The Optix Runtime tools are also installed via FactoryTalk Hub, and they are required on any machine that is going to run an Optix application.

FactoryTalk Hub: which hosts a number of FT applications (including FactoryTalk Design Studio for Optix)

Licensing and Pricing

Optix licensing is done on a token-based system, with more features requiring more tokens, and, therefore, a larger license. Generally speaking, the largest contributors to token usage are multiple concurrent web clients, OPC-UA connections, or database connections.

Examples of features that affect the sizing of your application include the following:

• Controller connections
• Multiple web clients
• Alarming
• Recipes
• PDF reports
• Data logging
• Database connectivity
• OPC UA connectivity

For more information on tokens and licensing, please see Rockwell’s documentation.

Presentation Engines

Presentation engines are responsible for rendering and displaying UI elements during runtime. There are two available presentation engines that can be used simultaneously – the native presentation engine and the web presentation engine.

The native presentation engine launches the project in its own window as an application.

The web presentation engine hosts the application on a web server, accessible via the defined web page. Multiple concurrent web clients can access the application (if multiple connections are defined in the web presentation engine), but more concurrent clients require more tokens.

Optix can make use of session-specific tools to allow concurrent clients to have different screens/panels open, have different users logged in, and display different information, provided that the Optix project was designed with multiple clients in mind.

An example configured Web Presentation Engine

Style Sheets

Style sheets allow the definition of default colors, shapes, sizes, and other UI element configurations. A project’s style sheet can be swapped during runtime. Some properties can be defined both in the style sheet and in an individual UI element. In the case that a property is explicitly defined for an individual element, it will override the style sheet.

An example Style Sheet

Screens and Panels

FT Optix uses screens, panels, and popups as the main methods for displaying UI elements. Screens and popups can both contain multiple panel loaders, which can be used to dynamically change displayed content when a defined action is performed, such as hitting a button.

To see panel loaders being implemented to create a dynamic device sidebar that changes what device it controls (and the associated UI elements) at the push of a button, stay tuned for our upcoming FactoryTalk Optix – Dynamic Device Faceplate blog post.

A panel loader that is a part of the main overlay of an application. It has the ability to load either a Motor or a GroundRack panel into the panel loader.

A runtime instance with the “Motor” panel loaded into the panel loader

A runtime instance with the “Ground Rack” panel loaded into the panel loader

Converters

Converters allow you to modify variables dynamically based on other variables. For instance, a key-value converter could change the text displayed in a string variable when a different integer variable’s value changes, and an engineering unit converter can be used to scale variable values differently.

There are more converter types and use cases that were not mentioned above. For more information on converters, stay tuned for our upcoming FactoryTalk Optix – Variables, Attributes, Dynamic Links, and Converters blog post.

A Key-Value converter that parses an integer out into valve status strings

Dynamic Links

Dynamic links are used to define relationships between two or more variables or attributes within the FT Optix project. Complex dynamic links allow the use of built-in converters, allowing further customization of UI elements.

For further information on Property Bindings, stay tuned for our upcoming FactoryTalk Optix – Variables, Attributes, Dynamic Links, and Converters blog post.

For an example of leveraging complex dynamic links, stay tuned for our upcoming FactoryTalk Optix – Dynamic Device Faceplate blog post.

A dynamic link that performs mathematical operations on several variables to return an adjusted distance

Events

Events call methods when a specific trigger happens, such as a button being pressed or a variable’s value changing. Events can be added onto most UI elements, and they can trigger multiple methods.

Methods

Methods are called by events. FT Optix has a number of built-in methods, but custom methods can be defined through NetLogic as well.

You can also create pre-defined method invocations, which allow the calling of methods with pre-defined parameters.

A list of common methods available in FT Optix

A custom method invocation for renaming a MySQL Database table

NetLogic

NetLogic allows C# code to be integrated and run in an FT Optix project. FT Optix can call parameterized methods, and they can send and receive variables with the C# project.

For further information on NetLogic, stay tuned for our upcoming FactoryTalk Optix – NetLogic Overview and Examples blog post.

An example NetLogic snippet that returns a localized time

Data Stores

Data stores are databases used to store values from different loggers and NetLogic (if you so choose). You can either use an embedded database, which is a simple SQLite database created with minimal overhead, or you can choose to create a connection to a database (SQL Server or MySQL). Other database types may be supported through ODBC connections, but they have not been tested or confirmed yet.

Loggers can be linked directly to a data store and will automatically configure tables for themselves on said database.

An example data store with an “Alarm Logger” linked to it, auto generating the necessary tables

Communication Drivers

Communication Drivers allow defining communication paths to PLCs and other devices, as well as the importing of tags and other information to be used in the Optix project. A list of the currently available communication drivers is available below.

All available communication drivers in Optix

The tag importer display from an example Rockwell Ethernet Driver linked to a PLC

Template Library

Optix’s Template Library

The template library stores templates created by Rockwell and allows you to create/import your own libraries as well. Some examples of useful templates that are included with Optix are:

• Alarm Grid
• Alam History
• Alarm Banner
• User Login Popup
• Confirmation Dialog
• Date and Time Display
• File Selector
• File System Browser
• Alarm Importer and Exporter
• Alarm Logger

Read the Other Articles in this Series

• FactoryTalk Optix Series 2 – Variables, Attributes, Dynamic Links, and Converters
• FactoryTalk Optix Series 3 – NetLogic Overview and Examples

The post FactoryTalk Optix Series 1 – Getting Started with FactoryTalk Optix appeared first on DMC, Inc..

This graphic may come in many forms. A steam plant, for example, may utilize a piping and instrumentation diagram (P&ID) to illustrate the movement and temperature of fluids throughout the building. The packaging room of a product manufacturing plant may utilize a CAD drawing of manufacturing equipment with overlays to indicate status. In any case, the graphic should be easily recognizable, quickly interpretable, and useful to a wide range of users.

In this blog, we will demonstrate how to create a custom animated graphic that satisfies these requirements for a SCADA application built in Ignition Perspective.

Ignition is one of the fastest-growing SCADA/HMI platforms Inductive Automation developed, and Perspective is the web-friendly visualization module that hosts user interfaces accessed from any web browser. Our clients often implement Perspective applications that are simultaneously accessed from industrial HMIs, tablets, laptop computers, and cell phones with ease.

The custom graphic created in this tutorial was implemented in the Ignition Perspective SCADA application of a client operating a consumer goods packaging plant. This tutorial is broken into the following sections.

1. Converting existing illustration to a web-friendly format
2. Importing drawings to Perspective
3. Creating an effective graphic with dynamic bindings

The following tools are needed to follow along with this guide:

• Inductive Automation Ignition, including the Perspective module and Designer installation —
• Adobe Creative Suite, including Photoshop and Illustrator
  • Note – free programs, such as Gimp, can also be used to follow this tutorial. Because DMC is a subscriber of the Adobe Creative Suite, which happens to provide some of most efficient tools for the job, these steps are not outlined in detail

Keep reading for step-by-step instructions to convert a 2D CAD drawing to a customizable Perspective graphic.

Converting Existing Illustration to SVG

A major benefit of Ignition Perspective is the ability to embed custom scalable vector graphics (SVGs) in the user interface. An SVG is a drawing file, like a CAD or PDF file, consisting of defined paths rather than fixed pixels. This difference allows the graphic to scale predictably without losing definition or quality. Scalability is an excellent quality for a graphic that will be displayed on devices with varying resolution. SVGs provide a path to custom graphics in Perspective without the need for a Designer-based illustration tool like that used in the Vision module.

Option 1: Convert straight to SVG

Some drawing files may be imported directly to Adobe Illustrator and saved to an SVG. This is the best-case scenario because only the pixels of interest will be saved from the drawing file. To do this, we simply open the file in Adobe Illustrator, crop if needed, and Export As an SVG. At this stage, ensure each piece of equipment in the drawing is separated into objects with appropriate names. This can be accomplished in Illustrator by creating layers with apt naming prior to export.

To confirm your SVG is in the correct format, open it with any text editor. The SVG should consist of some header information describing styles, size, and viewbox as well as a list of path objects. These objects will be displayed in Perspective as individual elements.

Figure 1: Example of CSV with single element, "sorterFill." Note: that path has been cutoff for conciseness.

Option 2: Extract drawing with image editing software

Other drawing files are not provided in a scalable format or are too complex to be redrawn on your machine. In this case, we can use an image editing software to extract the shapes of interest from the provided drawing.

Step 1: Import illustration to Photoshop (or other photo editing software)

For this example, we start with a customer’s 2D drawing file in the locked DWG format. Similar processes can be followed for PDFs, DWFs, PNGs, etc. This file contains the top-down drawing of the packaging room floor. Since our photo editing software cannot directly import a DWG file, we will first print the drawing to a high quality TIF image. We will do this with  DWG TrueView, a free program from Autodesk. The output filetype is not as important as the quality and size of the image. We only need to convert it to a filetype that our image editing software can process. 

This TIF file can be dropped into the image editing software. In this guide, we will use Adobe Photoshop. Once dropped into Photoshop, adjust the image to fill your canvas, and rasterize it with the confirmation button.

Step 2: Use the Magic Wand tool to select the parts of the drawing to be animated

Hint: unchecking the “Contiguous” box in the Magic Wand properties ribbon allows for quick selection of background in grayscale images. In our example, we use the Magic Wand to quickly select all white pixels. Right click > Select Inverse yields the selection of all grayscale pixels. 

Step 3: Layer Via Copy

Right click the selection and create a new layer via copy using the provided menu. The original layer can be disabled to view only the selected pixels.

Step 4: Clean up Selection

At this point, we can use our photo editing software’s eraser tool to remove pixels from the animation. In our example, we will remove electrical enclosures and repeated hardware.

Step 5: Separate equipment into unique layers and create Fill Layers

Use any selection tools necessary to select and separate the drawing into equipment regions. Separate the regions by right clicking the selections and creating new layers via cut. When finished, we should have a layer for each piece of equipment and nothing else. Delete any background or leftover layers.

Once the equipment is separated into layers, each one must be used to create a new Fill Layer. A Fill Layer is needed to vectorize the pixels in preparation for exporting to SVG. First, select all the pixels for a given equipment layer. This can be done by right clicking the layer preview and selecting “Select Pixels.

Once the pixels are selected, right click the selection, and select “Make Work Path.”A popup will prompt the user for a tolerance. This setting may be adjusted if results are not satisfactory. For our example, we selected a tolerance of 1 pixel. Images with denser pixel date may not require such a tight tolerance.

Create a new Fill Layer using the dropdown navigation: Layer -> New Fill Layer -> Solid Color. Select a neutral color, presumably black, and name the layer appropriately. Names selected here will be displayed as properties in the Perspective project object, so they should be intuitive.

Step 6: Export as SVG

Once a fill layer is created for each division of equipment, disable all other layers. Only the fill layers should be displayed in the editing window. At this stage, we are ready to export our SVG. Use the dropdown navigation to select Export As, and select SVG from the dropdown menu in the popup that appears.

Note: you may want to ensure the drawing is in the proper orientation. This step is not critical but will make responsive resizing in Perspective windows much smoother. Image rotation in Perspective can be accomplished, but it currently requires nesting in a coordinate container.

Import SVG to Ignition Perspective Project

Now that the SVG was created from the provided system drawing, it can be imported to the Ignition designer. The easiest way to do this is to drag and drop the file into a blank Perspective view. For this example, we are employing a flex container. Ensure that the SVG is embedded and not linked in the view.

Once the drawing is embedded, the component will appear in the Project Browser. Browse the `elements` property to ensure that all layers have imported successfully as separate elements.

For our example, we set Grow and Shrink properties to 1and allowed the basis to be set automatically. This ensures maximum responsiveness in embedding views. It may also be reasonable to set minHeight and minWidth constraints on the SVG component, or flex container, if needed for a given application.

Create Intuitive Overlays and Animations in Perspective

Each element of the SVG component can be customized like other Perspective components. Namely, a “style” object may be defined for each element to employ standard Perspective CSS-esque customization. For this example, we will be animating/coloring the pieces of equipment drawing based on OPC status tags using Perspective styles.

Step 1: Create Perspective styles

For this example, we will use style to change the color and of each piece of equipment. This is not the only way of animating equipment with styles. Border, transparency, and visibility can also be customized for a more inclusive design. Let’s first define our “alarm” class. When this class is applied, we want the equipment to flash between red and black at a fixed rate. Use the Timing and Shape/Fill properties to accomplish this.

Step 2: Create dynamic bindings

Once styles have been created, they need to be dynamically assigned to the class property of each element of the SVG. This can be accomplished in a few ways:

Option 1: Create bindings for each element

For simple drawings, a binding may be defined for each object in the SVG. For each element, create a “style” object with a “classes” value. This value will be bound to the appropriate OPC tag. In our example, we use an indirect tag binding to retrieve the equipment status from tag UDTs. Two transforms are then applied: a script transform to check tag quality — end user wanted custom error behavior — and a map transform to select the appropriate predefined style from an enumeration.

Option 2: Update style classes via scripting

For complicated drawings with many pieces of equipment, scripting may be a more efficient use of developer time. Consider creating a timed event or a custom root property with a polling expression binding to execute the following pseudo code:

This allows the styling to be set without configuring individual bindings on each element. For this code to work, the names of SVG elements must match tag names in the tag provider UDT that is supplying status information, and the eqPath parameter of the view must be a valid tag path to a UDT instance.

Once our bindings have been created, we are ready to embed the animation throughout the project.

In this guide, we've learned how to create a custom illustration and animation from a 2D drawing file and import it to an Ignition Perspective project. To learn more designing dynamic Perspective projects, see Caz’s series of blogs listed below!

Learn more about DMC's Ignition expertise, and contact us to get started on your next HMI, SCADA, or MES project!

See other blogs related to this topic: Creating Dynamic Ignition Perspective Projects
Part 1: Bindings and Transforms
Part 2: Button Event Actions
Part 3: Embedded Views and Flex Containers
Part 4: View Parameters, Indirect Bindings, and Flex Repeaters

The post Creating Custom Graphics for SCADA HMIs with Ignition Perspective and Photoshop appeared first on DMC, Inc..

Setup: WinCC OA Manual Generation

The first thing you need to do is create your assets in both the WinCC OA project and the MindSphere tenant. I’ll start with the WinCC OA project. Open Gedi in your project and from the top toolbar navigate to ‘SysMgm’ < ‘Settings’ < ‘MindSphere Configuration.’ This will open a window like the one shown below.

Within here you can manually instantiate datapoints for you MindSphere application. There are three levels of organization to your MindSphere data. At the highest level are assets, then within an asset, there are data sources, and within those data sources, there are datapoints.

What exactly defines an asset or data source within your project is up to you. For instance, an asset could represent one of several lines on a factory floor, and each data source could be a machine or PLC used within that line. It is up to you to decide how best to structure your data.

To create an asset, simply right click the whitespace in the column on the left and select ‘Create MindSphere Asset.’ You can right-click that asset to add a data source and right-click that data source to add datapoints. When creating assets and data sources, all you really configure is the name. When creating datapoints, you must also select a datatype and enter the units. Datatype selection is limited to ints, longs, double, Booleans, and floats, so be aware of this when creating your application. It is also crucial that you do not leave units blank.

To map your OA data point to a data point in an asset in MindSphere, the units on the two data points must match exactly. We’ll touch more on this later.

Setup: WinCC OA Scripted Generation

If you are working with a large volume of datapoints, then manually entering them all, as I showed above, can be impractical. Fortunately, there is a way to script the generation of these points. Whenever an asset, source, or point is created in the MindSphere Configuration menu, an internal datapoint is created in Para of the type _MC_Asset, _MC_Datapoint, or _MC_Datasource respectively.

What this means is that you can write a script that uses the dpCreate and dpSet functions to create your data structure and populate some necessary fields. You must be careful when doing this, though, to set up your data correctly. Make sure your asset’s DataSources is populated with the names of all associated data sources.

Do the same for making sure the data source has its associated points and assets entered and that the points have their associated data source. Don’t forget to set your points’ unit and type as well. Type is represented by an integer from 1 to 5, where each number equates to one of the datatypes mentioned earlier. Try first making a simple data structure as I did here and dig around the generated internal points, so you understand how it’s all supposed to be set up.

Setup: MindConnect Lib Asset

Next, we will create our MindConnect Lib asset. The MindConnect Lib assets are what your assets in OA are going to establish a connection with an upload data to. There is a one to one relation between MindConnect Lib assets in the tenant and assets in your OA project so you will need to make one MindConnect Lib asset for each asset in your OA project.

From your home page in MindSphere, go to the asset manager and select ‘Create asset.’ Select MindConnectLib and give your asset a name.

Next, we’ll set up our connection to the OA asset. Click the large button with the puzzle piece on it and select your preferred security profile.

I’ve used SHARED_SECRET for all of my applications. After hitting continue, you’ll be taken to another screen with the boarding configuration. Click the buttons to generate a boarding key and copy it to your clipboard.

Now go back to the OA MindSphere configuration menu, click on your asset, and paste the onboarding key into the white box then hit the upload button at the bottom.

Your assets in the OA project and tenant are now connected. You’ll notice that the Configuration ID has been filled in for your asset and all associated datapoints. Now, if you go back to your asset in the MindSphere tenant and click the button with the puzzle piece on it, you’ll be taken to a new screen.

Here you can see the configuration of your asset and its data mappings. The configuration shown should match exactly with what you set up in OA.

Setup: MindSphere Assets for Data Mapping

To actually work with and visualize the data that you’re sending to you MindConnect Lib asset, you need to create assets to map that data to. To do this, you will need to create some aspects and types. Both aspects and types are configurable data structures. A type will contain aspects, and you’ll create instances of types in the assets menu like how you create the MindConnect Lib asset.

Similar to the structure of the MindSphere configuration in the OA project, it’s up to you to decide how best to structure your data. To make an aspect, go to your tenant’s asset manager, select ‘Aspects’ from the menu on the left, and select ‘Create aspect.’ Add at least one variable to make a valid aspect and make sure to set a ‘Unit’ value that exactly matches the units you set up in OA for the data point you intend to map to it. You will not be allowed to map your data points if the units don’t match.

Similar to how you created an aspect, you will now create a type. Types are just another layer in the data hierarchy of MindSphere. Types can contain variables, aspects, and have an associated image for an organization. Additionally, an instance of a Type is an asset, whereas you cannot instantiate aspects as assets.

Add whatever aspects and variables seem sensible for your type, but be aware that you cannot map your OA data points to the standalone variables in a type. They must be mapped to a datapoint in an aspect in that particular type.

Now go back to assets and create an instance of the type you just created. Go to the Configuration/Data mappings page for your MindConnect Lib asset and go to the Data mappings tab. If you expand the data structure you should see a button that says ‘Link variable’ for each data point. Click on that and navigate to the appropriate data point in the instance of the custom type that you created.

Once mapped, it should look something like the above image. Something significant to note is that these datapoint mappings are somewhat fragile, and any changes made to your OA assets, like adding points or sources or changes units, will undo these mappings. For that reason, you should try to finalize your data structure as much as possible before going through the effort of mapping points.

Pushing Data to MindSphere

You have now made all the necessary arrangements and are ready to push that data up to MindSphere from your OA project. I’ve made a straightforward script that goes over all the essential actions that must be done to upload data.

#uses "classes/mindSphere/MindSphereAsset"

// Example script showing how to push data from OA to MindSphere

main()
{
    // Instantiate a MindSphere asset
    MindSphereAsset asset = MindSphereAsset("TestAsset");

    // Generate sample values
    dyn_int testValues = makeDynInt(
        13,
        67,
        89
    );

    // Create timestamps for the samples
    time currentTime = getCurrentTime();

    dyn_time times = makeDynTime(
        currentTime - 2,
        currentTime - 1,
        currentTime
    );

    // Prepare values for upload
    int err = asset.prepareValues(
        "TestPoint1",
        testValues,
        times
    );

    // Upload values to MindSphere
    err = asset.uploadPreparedValues();

    if (err == 0)
    {
        DebugN("Upload Successful!");
    }
}

#uses "classes/mindSphere/MindSphereAsset"

// Example script showing how to push data from OA to MindSphere

main()
{
    // Instantiate a MindSphere asset
    MindSphereAsset asset = MindSphereAsset("TestAsset");

    // Generate sample values
    dyn_int testValues = makeDynInt(
        13,
        67,
        89
    );

    // Create timestamps for the samples
    time currentTime = getCurrentTime();

    dyn_time times = makeDynTime(
        currentTime - 2,
        currentTime - 1,
        currentTime
    );

    // Prepare values for upload
    int err = asset.prepareValues(
        "TestPoint1",
        testValues,
        times
    );

    // Upload values to MindSphere
    err = asset.uploadPreparedValues();

    if (err == 0)
    {
        DebugN("Upload Successful!");
    }
}

Note the steps in the above script. You must first instantiate your asset within your script via the MindSphereAsset function. The string inputted here must be identical to the name of the asset you created earlier in the configuration menu.

Next, I make an array of sample data to upload. You can also upload points one at a time, but it will be more computationally intensive. For every bit of data that you create, you also need a timestamp. Here I take the current time then have offsets by one and two seconds. Before you upload your values, you must prepare the values for upload.

The first input here is the name of the datapoint you’re uploading to, and it must match exactly with the name of the intended datapoint. After you’ve prepared your values, call asset.uploadPreparedValues to upload all values that have been prepared for that asset since the last successful attempt to upload values. You can call asset.prepareValues as many times as is necessary before executing the upload, and uploading data in large batches rather than small chunks will be a lot faster computationally.

If the upload was successful, then the value of err, the output from the upload function, should be equal to zero.

Viewing Your Data in MindSphere

There’s a ton that you can do with your data once it’s in MindSphere, but that’s a whole different discussion, so here we are simply going to view the time series of our data. To view your data, go back to the home page of your MindSphere tenant and navigate to the Fleet Manager. Search for the instance of your custom Type that you created and click on it. The page should then show all the aspects associated with your type in the central window. Click on an aspect to see the time series of incoming data. To view data that cannot be graphed, like strings and Booleans, click on the checkerboard looking button in the bottom right corner under the graph.

As you can see in the figure below, there are two instances of the three values I sent with my simple script because I ran the script twice.

Final Tips

• Take time to plan out your data organization in advance.
  • The systems of aspects, types, and assets and points, sources, and assets can seem convoluted at first, but if you take the time to plan out your project, then these organizational layers can prove very useful.
• Be careful of breaking your tag mappings in MindSphere.
  • Remember that making any changes to your OA asset configuration will break all of your tag mappings, and you will have to delete and reestablish those mappings manually. This is another reason to have a good organization plan in mind before digging into things.
• One call to Upload 1000 datapoints is a lot faster than 1000 calls to upload one datapoint each.

Learn more about DMC’s WinCC OA services and our Siemens expertise. Contact us with any inquiries. 

The post How To Setup a WinCC OA Application to Push Data to MindSphere appeared first on DMC, Inc..

History

WinCC OA is provided to users as a clean sheet. It has incredibly powerful ways of creating reusable and self-configuring objects, but this is “an exercise left to the user,” as my old college professors would say. Rather than continually reinvent the wheel each project, we decided to distill best practices into a set of tools that integrate seamlessly into the Siemens PLC Open Library. This resulted in the alpha version of a WinCC OA Open library in July 2017.

This initial version was a great start for clarifying how to use the new WinCC OA Object-Oriented CTRL++ language that had just been released. Several revisions later, we have an extensible code base covering the key elements of the PLC Open Library and are ready to share it with the world.

Components

This latest version has implemented the critical portions of the PLC Open Library with objects for:

• Motor – Contactor
• Motor – VFD
• Pump – Contactor
• Pump – VFD
• Valve – Solenoid
• Valve – Analog
• System Control Object
• Interlock Object
• PID Compact Object

There are plenty of helper objects, such as the text indicator and entry objects not listed here that are used by the objects above. These can often be utilized by themselves as part of your project or embedded into your own custom objects!

Look and Feel

These objects have behavior and visualization that is similar to the PLC Open Library while still extending the functionality to provide for the benefits of using WinCC OA.

One of those extra benefits that WinCC OA provides is the ability to use color schemes. Color schemes are sets of named colors that can be swapped into place on a system during runtime. This ability allows for implementations like day/night mode.

In this case, we implemented the DMC Open Library standard color set and a High-Performance HMI color set. You can create your own color set and customize the color scheme to whatever works for your project.

Utilities

Tag creation in SCADA systems can be a daunting task. This task is especially true when you have smart objects with a rich tag structure like the PLC Open Library.

As a result, we needed to create a better way to manage tag generation for the Open Library. The included tool allows a DB export from a Siemens PLC to be converted to an import file for WinCC OA. With the included capability to handle descriptions, units, formatting, and naming, the work of days can be reduced to minutes with this tool!

Conclusion

WinCC OA is a very powerful platform that gives the user a level of flexibility and capability not seen in other platforms. This power comes at the cost of increased development effort to create a set of objects for any given project.

The Open Library toolset helps bring a robust set of pre-built objects to WinCC OA and provides a base to build new objects from without having to start from a clean sheet each time.

Learn more about DMC’s HMI Programming and WinCC OA services and expertise. Contact us for more information or any project inquiries.

The post Siemens WinCC OA Open Library appeared first on DMC, Inc..

For my example, I will demonstrate on a TP700 Comfort Panel, although the same basic procedure can be used for a Basic Panel or an Advanced Runtime system. To start things off, I've created three internal HMI tags: An alarm word (UInt) for triggering of my example alarm, a string to contain the name of the logged in user, and a real tag for my process value example.

First, I've written a short script to capture the name of the logged in user and created a task to call my script on any user change event. Obviously, this part of the demo is specific to WinCC Comfort or Advanced as the Basic panel will not support scripting, but it will not affect our alarm text demo. Next, I've created several users to allow myself to log in to our example HMI.

Now I've created a single discrete alarm, triggered off of Bit 0 of my alarm word with some simple static text, "Max Speed Limit Exceeded."

Let's pretend for the moment, though, that we would like to include the actual limit in the alarm text for both display and posterity, as well as the operator that forced the system to exceed that limit. If the limit was not configurable, we could hard code it in the message. And if there were only a few users, we could potentially create an alarm for each user. However, if users can be created dynamically and the limit is a configurable parameter, there is no way of creating all of the possible alarm messages that may occur. Luckily, we can create dynamic alarm text.

To create dynamic alarm text, select the alarm from the alarm list and view alarm properties. Now, right-click in the "Alarm Text" field and you will see two options: "Insert tag field…" and "Insert text list field…"

I'm going to use "Tag Field." Notice that when you select it, a dialog will open allowing you to configure the field. In this example, I will use the process value tag I previously created, and configure it to display as a decimal with length three. As you can see, it is also possible to use Text Lists directly within an alarm, which allows you to create even more dynamic alarms.

Next, I added in an additional tag to display the name of the operator.

That's it. Now I'm going to set up a quick example screen with an alarm viewer and controls for setting my process tag and triggering my alarm, as well as displaying the currently logged in user. Now if I trigger my alarm, you can see that my alarm text is dynamically generated.

I hope this is helpful!

Learn more about DMC's PLC Programming services and contact us to get started on your next PLC Programming project.

The post Customizing HMI Alarm Text in TIA Portal appeared first on DMC, Inc..