Connect to an OPC UA Server with an Ignition Edge Gateway

I've lost count of how many system architects I've spoken to who have hit the same wall. They've brilliantly connected their Modbus PLCs, gathered all this rich OT data at the edge... and then what? It's sitting on an edge device, an island of data in a sea of operational potential. Getting that data to the central IT systems—where the real enterprise-level magic happens—is the final, and often frustrating, mile. This is the classic data silo problem, and it's where many IIoT projects stall.

Let's be clear: collecting data is only half the battle. The real value is unlocked when that data is integrated into your broader business systems. In our last discussion, we covered how to turn the Robustel EG5120 into a powerful data acquisition machine with Ignition Edge. Now, we're tackling the next critical step: securely and reliably forwarding that data to a central OPC UA server. This isn't just a technical exercise; it's the very essence of OT/IT convergence. It’s how you transform isolated machine data into actionable business intelligence.

So, you've successfully gathered your data on the Ignition Edge gateway. What's next? The crucial step is to push this valuable information to a central, third-party server where it can be analyzed and acted upon. This could be a major cloud platform like AWS or Azure, a traditional SCADA system, or, for many industrial applications, a dedicated OPC UA server. The goal is to break data out of its silo at the edge and integrate it with your wider IT infrastructure.

Let's be clear: the Robustel EG5120 running Ignition Edge is not a one-trick pony. It’s a versatile data bridge capable of communicating with numerous platforms. We're focusing on the OPC UA server here because it perfectly illustrates the power of this capability. For decades, OT and IT have operated in different worlds. OT speaks Modbus, S7, and other legacy protocols; IT speaks SQL and REST APIs. An Ignition Edge gateway acts as the perfect translator, and using a standardized destination like an OPC UA server is the key to creating a universal language for your entire enterprise.

The real "aha!" moment for many engineers is understanding the value of this translation. When your EG5120 converts raw Modbus data and forwards it to an OPC UA server, it's doing more than just moving bytes; it's transforming cryptic data points into a structured, self-describing information model that IT systems can immediately understand. This protocol conversion is the foundation of digital transformation, allowing you to:

• Create a Single Source of Truth: All your disparate field devices can now report their data in a unified format to a centralized platform, like an OPC UA server, creating a cohesive view of your entire operation.
• Enable Enterprise-Wide Visibility: Once your data is on a standard server, it can be easily consumed by SCADA systems, ERPs, data analytics platforms, and business intelligence dashboards.
• Future-Proof Your Architecture: Standards like OPC UA are modern, secure, and platform-independent. By standardizing how your edge data is presented to your IT systems, you ensure your architecture is ready for future technologies and applications.

Let's face it, industrial environments aren't data centers. Cellular and Wi-Fi connections can be unstable, especially in remote or mobile applications. What happens if your EG5120 loses its connection to the central OPC UA server for five minutes? Do you simply lose five minutes of critical production data? For any serious industrial deployment, the answer has to be a resounding "No."

This is where the power of a true Ignition Edge gateway comes into play. Ignition Edge has a built-in mechanism for this exact scenario, often called "store-and-forward."

Here's how it works in my experience:

1. Data Acquisition Continues: The EG5120 continues to poll data from the local Modbus PLC without interruption.
2. Buffering at the Edge: Ignition Edge detects the broken connection to the remote server and begins buffering the time-stamped data locally on the EG5120's reliable eMMC storage.
3. Automatic Forwarding on Reconnect: The moment the network connection is restored, Ignition Edge automatically forwards all the buffered data in the correct chronological order.

This isn't just a cool feature; it's an absolute necessity. It guarantees data integrity and ensures that your central analytics and historical records are complete, providing a reliable dataset you can actually trust for decision-making.

Theory is great, but let's get practical. How do you actually make this happen? Based on our hands-on user guide, here’s a streamlined walkthrough of the key steps to configure your Ignition Edge gateway to forward data to an external OPC UA server.

First, you need to teach Ignition Edge how to talk to your central server. This involves setting up a client connection from the gateway to the destination.

1. Log into your Ignition Gateway Web Interface and navigate to Config > OPC Connections.
2. Create a new OPC UA Connection. You'll need the Endpoint URL of your Prosys Simulation Server or your production server.
3. Establish Trust. Security is paramount. You'll need to manage security policies and trust the server's certificate. The connection will initially show as "Faulted" until this two-way trust is established. Once complete, the status should change to "Connected."

With the connection established, how do you move the data? The most flexible and efficient method is using a Tag Event Script. This script runs automatically every time your source tag's value changes.

1. Open the Ignition Designer and locate your source tag (e.g., the Modbus tag we created previously). Right-click and select "Edit tag...".
2. Navigate to the Scripting Events. In the Tag Editor, find the "Value Changed" event and open the script editor.
3. Write the Python Script. You'll enter a short Python script that performs one key action: it takes the new value from the source tag (currentValue) and writes it to the destination tag on the remote OPC UA server. The system.tag.writeBlocking() function is your best friend here.

Python

# A simplified example of the core logic # Fired whenever the Modbus tag value changes def valueChanged(tag, tagPath, previousValue, currentValue, initialChange, missedEvents): # Define the full path to the tag on the remote OPC UA server destination_tag_path = "[Prosys_Connection]Objects/MyObjects/Simulation/Random" # Get the new value from the source tag new_value = currentValue.getValue() # Write the new value to the destination tag if currentValue.getQuality().isGood(): system.tag.writeBlocking([destination_tag_path], [new_value])

Once you save this script, the data forwarding is live! Every change in your Modbus device is now instantly and automatically mirrored on your central server. It's OT/IT convergence in action.