OPC-UA Interface Guide (Meteor Inkjet)

Meteor Pane Plugin v4.11.6782.0, Copyright (c) 2024 Global Graphics Software. All rights reserved.

Overview

The Meteor Pane Plugin allows a user to obtain up-to-date information about the state of any attached Meteor hardware.

When the Open Platform Communications (OPC) server in Meteor Pane Plugin is enabled an OPC node tree is published. The nodes in this tree represent grouped areas of state and functionality.

For example, a Server section allows:

• the RIP Server name, location, and version.

• the associated Meteor status data.

• Product Detect signals to be sent.

• ...and more.

Default address: opc.tcp://localhost:26642/spc-meteor

Meteor Router

For the OPC information to be up-to-date the plugin must communicate with a MeteorRouter process running on each Windows RIP Server machine.

If using Meteor on CentOS-based RIP Servers you must ensure the Meteor_Output_Plugin.json config templates set SPDHost to true.

Certificates

Communication between OPC UA clients and servers require both parties to possess their own application certificate. To enable further communication each party must trust the opposing certificate. This trust can be established automatically, programmatically or manually depending on the application's configuration or implementation. The certificate for SPC can be found in %programdata%\Global Graphics Software Ltd\Meteor Pane Plugin\App Certificates\certs should you need to copy it to the Trusted Peer Certificate folder. In this release it will be a Self Signed Certificate issued by and for Smart Print Controller.

OPC Nodes

The OPC node mechanism will report when any state changes (at all server/controller/head levels), allowing clients to react accordingly. The period at which these state changes are detected is governed by the Servers.RefreshPeriod value (Default: 0.5s), which can be modified at runtime.

Turning on Servers.EnableDebugLogging will allow closer monitoring of when state is refreshed and what values are being reported.

NOTE Updates from SPC will be paused when it has been instructed to release the printer interface. In this state, SPC cannot interact with the Meteor API, and no status updates will be provided until the interface has been reacquired. Clients relying on updates should ensure proper acquire/release handling.

NOTE The Servers.IsApplyInProgress property indicates whether SPC is currently in the process of applying a new device configuration. During this phase connections to the Meteor server(s) is unreliable, and clients should not attempt to interact with the Meteor system until this property is false.

Server/Controller/Head Tree

The Server/Controller/Head tree is the structured node hierarchy representing different levels of the system state.

Controller Node Naming vs. Controller Numbers

Each ControllerN node (e.g., Controller1, Controller2) has a numeric suffix is purely for node uniqueness and does not represent the actual controller ID. To identify specific controllers, refer to the ControllerNumber property within each node, which reflects the actual controller ID specified from the Meteor configuration.

Dynamic Changes and Node Behavior

• The ServerCount, ControllerCount, and HeadCount properties enable real-time monitoring of the hierarchical structure.

• These properties dynamically update in response to system changes. If servers, controllers, or heads are added, the node tree grows accordingly, allowing clients to subscribe to new nodes.

Node Dormancy and Subscription Stability

Even when the ServerCount, ControllerCount, or HeadCount decreases:

• Nodes beyond the current count are not removed but become dormant.

• Dormant nodes do not send updates until reactivated by an increase in the corresponding count.

This ensures OPC clients do not need to manage unsubscriptions manually.

For example, if a client subscribed to updates from Controller3 but the system reduces to only two controllers, the client will no longer receive updates for Controller3. However, if additional controllers are added later, updates for the new controllers will resume automatically.

This mechanism ensures that clients never need to unsubscribe from nodes they are no longer interested in.

Connecting to Controller Boards

Each Controller-level node represents a single Meteor controller board, and contains several sub-nodes.

The IsConnected property indicates whether the controller board is currently powered on and connected to the Meteor system. It might take a while for this property to become true after the controller is initialized, so callers should check the value periodically, especially prior to starting a print run. If one or more controllers fail to connect, OPC clients can call the Servers.AbortBoot method to abort the controller boot process. This ensures the system does not hang indefinitely waiting for unresponsive controllers.

The ControllerCount property indicates the number of controllers currently defined in the Meteor system.

The ConnectedControllerCount property indicates the number of controllers currently connected to the Meteor system. Clients may monitor this property to check if the required number of controllers ('ControllerCount') are connected.

OPC Methods

Any methods listed in this documentation will include details about their required parameters (if any), and return value.

In the event of an error please see the application log file for more information.

OPC Client Library

The following documentation provides guidance on using the Traeger Industry Components GmbH OPC client library for software developers working with Meteor Pane Plugin.

Configuring Custom Message Sizes

The default maximum message sizes used by OPC clients to communicate to the server are sufficient for most use cases. However, to ensure transfer of larger data packets (such as retrieving some job thumbnail images) it may be necessary to configure the OPC client with custom values.

For example:

	Client = new OpcClient();
	Client.Transport.MaxArrayLength = 1024 * 1024 * 50;
	Client.Transport.MaxBufferSize = 1024 * 1024 * 50;
	Client.Transport.MaxMessageSize = 1024 * 1024 * 50;
	Client.Transport.MaxStringLength = 1024 * 1024 * 50;

See here for more information.

Adjusting Communication Timeouts

OPC clients regularly verify the responsiveness of the connection to the OPC server. However, in certain circumstances where the system is under heavy load, maintaining a responsive connection might not always be possible. To mitigate potential issues under such conditions, it is recommended to increase the default communication timeouts.

The example below demonstrates how to adjust the default values:

	var defaultTimeOut = (int)TimeSpan.FromMinutes(10).TotalMilliseconds;
	Client = new OpcClient
	{
	    // Don't auto-disconnect - Dispose the client to explicitly disconnect.
	    DisconnectTimeout = int.MaxValue,
	    KeepAlive = { Interval = defaultTimeOut },
	    SessionTimeout = defaultTimeOut,
	    OperationTimeout = defaultTimeOut,
	    ReconnectTimeout = defaultTimeOut
	};

Please note that the provided examples serve as illustrations, and it's important to tailor the configuration to your specific requirements.

MeteorMonitorSet

The top-level set containing all available OPC nodes.

Immediately underneath this root-level node are a categorized collection of sub-nodes, each encapsulating a different area of behavior.

Plugin

State relating to the Meteor plugin.

Properties

Servers

State relating to the collection of registered RIP Servers.

Details

The OpcServers class provides state and methods for managing SPC's interaction with the Meteor API through OPC interfaces.
This includes acquiring and releasing printer interfaces, which are critical for ensuring proper system monitoring and operation.

NOTE The Meteor Monitor plugin will automatically acquire the Meteor printer interface when it is first launched.

ReleasePrinterInterface()
Use this method to relinquish SPC's control over the Meteor printer interface, allowing an OPC client to make its own calls to the Meteor API directly.
NOTE Must be paired with a call to AcquirePrinterInterface() so SPC can regain control of the Meteor API.

NOTE When SPC has been instructed to release the printer interface, it will no longer interact with the Meteor API (e.g., updating status fields, controlling head power) until the interface is reacquired with a call to AcquirePrinterInterface().

AcquirePrinterInterface()
Use this method after a call to ReleasePrinterInterface().
This enables SPC to take back control of the Meteor printer interface, enabling it to monitor and manage the system, update status fields or controlling head power, etc.

Properties

Methods

Server1

State relating to a single RIP Server. (The numeric suffix will change as appropriate.)

Properties

Methods

Controllers

State relating to the collection of head controllers.

Properties

Controller1

State relating to a single head controller. (The numeric suffix will change as appropriate.)

Properties

Heads

State relating to the collection of print heads managed by the parent controller.

Properties

Head1

State relating to a single print head. (The numeric suffix will change as appropriate.)

Properties

Status

State relating to the Meteor status data of a single RIP Server.

Properties