User Guide (SmartRIP)

Smart RIP OPC API

Smart RIP v1.0.0.0, Copyright (c) 2025 Global Graphics Software. All rights reserved.

Overview

The Smart RIP allows system integrators to deliver print capabilities into an industrial sector via a simple OPC UA interface.

Key Features:

• No User Interface - Headless, OPC UA only.

• Single-Job Processing - Handles one job at a time, pages can be rendered on demand.

• SMD-Based Configuration - Set up via Smart Media Manager files without needing changes to SMM.

• OPC Server Support - Basic progress reporting, logging, and debugging.

• Plugin Commands - Send plugin-specific commands during an active print run, for example Meteor configuration. Use the full output plugin name, such as Meteor_Output_Plugin.

• Meteor Node - When the Meteor development SDK is installed, low-level Meteor methods are grouped under the Meteor node for active Meteor print runs.

• Color Support - CMYK + spot colors like white/varnish.

When the product is launched its Open Platform Communications (OPC) server will publish an OPC node tree. The nodes in this tree represent grouped areas of state and functionality.

Default address: opc.tcp://localhost:26942/smartrip

MediaBridge

The Smart RIP application ships with an optional component called MediaBridge.

MediaBridge acts as a 'go between' between Smart Media Manager (our software for creating Smart Media (.smd) files) and the Smart RIP. When the MediaBridge is running, SMM will 'print' to the Smart RIP via the bridge.

When MediaBridge is running, it will show a taskbar icon next to the Windows clock area. This allows the user to easily exit the app, or view its application log.

NOTE: For MediaBridge to work correctly it must be run after the Smart RIP and before Smart Media Manager.

Once the user has created the media they require (for use with Smart RIP), the MediaBridge is not needed.

License Activation

The user has a chance to license the app at install-time. If they choose not to do this, then they'll need to use the /License command to activate it with a valid license key:

SmartRip.exe /License <your-license-key>

This activation only needs to be performed once after installation. Once activated, Smart RIP will remember the license for subsequent runs.

Getting Started

This section provides a step-by-step guide to get you started with Smart RIP using the OPC UA interface.

Basic Workflow

The typical workflow for using Smart RIP follows these main steps:

1. Install Media - Configure printer settings for the physical media

2. Prepare Job - Load the print job and configure properties

3. Start Print Run - Initialize the RIP for printing

4. Print - Submit the job for processing

5. Stop Print Run - Clean shutdown when printing is complete

Optionally, you can generate thumbnails before printing by calling StartThumbnailing() after preparing the job but before starting the print run.

Step-by-Step Guide

1. Install Media

Before printing, at least one media configuration (.smd file) must be installed that defines printer settings, color adjustments, and other parameters for the physical media.

Use the Media node to install media files either from a shared file path or by uploading in chunks. Installing a media returns the media name that will be used in subsequent operations.

Installed media configurations remain available between application restarts.

2. Prepare The Job

Configure the job settings and upload the print file using the Prepare node:

• Set the OutputType property to specify which output format to use for printing (e.g., Tiff for image files you can easily examine)

• Set the OutputPath property to specify where output files should be written (required for Tiff and other file-based output)

• Set the MediaName property to specify which installed media to use

• Set the CopyCount property to specify the number of collated copies (defaults to 1)

• Load the job file using either LoadJobFromPath() for shared files or LoadJobFileChunk() for client-only files

State Changes: During job preparation, the Print node properties remain:

• JobState: NotStarted

• PrintRunState: Stopped

• PagesProcessed: 0

• PagesTotal: 0

3. Start the Print Run

Initialize the RIP with the job configuration by calling PrintRunStart() on the Print node.

NOTE: Both a job file and media must be specified before making this call.

NOTE: This call returns immediately and the initialization occurs asynchronously. Monitor the PrintRunState property to confirm the print run has started successfully.

State Changes: The PrintRunState transitions as follows:

4. Start Printing

Submit the job for processing by calling StartPrinting(pageRange) on the Print node. Pass an empty string or "1-" to print all pages, or supply a standard page range string (e.g., 1-3,5, odd, even).

This call returns immediately. Monitor progress using the Print node properties:

• JobState - Current job status (NotStarted, Printing, Success, ...)

• PagesProcessed - Number of pages completed

• PagesTotal - Total pages in the job

• PrintRunState - The state of the print run (Stopped, Starting, Started, ...)

State Changes: During printing, properties change as follows:

NOTE: JobState can also transition to Failed or Cancelled if errors occur or the job is aborted.

If the output type results in files written to disk, they will be at the location specified by the Prepare.OutputPath property.

5. Stop the Print Run

When printing is complete, call PrintRunStop() on the Print node to properly shut down the print run.

NOTE: This call returns immediately. Monitor the PrintRunState property to confirm the print run has stopped.

State Changes: The PrintRunState transitions as follows:

Plugin Commands

While the print run is active, plugin-specific commands can be sent with Print.RunPluginCommand(pluginName, command). This is intended for plugins such as the Meteor output plugin. The pluginName must be the full output plugin name, such as Meteor_Output_Plugin.

OPC example:

Print.RunPluginCommand("Meteor_Output_Plugin", "GET_OUTPUT_MODE")
// Example response: NON_CONTINUOUS

Meteor Printer Interface Ownership

The Meteor node also exposes AcquirePrinterInterface() and ReleasePrinterInterface().

Use ReleasePrinterInterface() when an external OPC client needs to make its own Meteor API calls directly.

While the printer interface is released, Smart RIP deliberately stops making Meteor API calls. Meteor status may stop updating, and Meteor methods exposed by Smart RIP will not work again until the interface is reacquired.

Use AcquirePrinterInterface() to hand control back to Smart RIP once the external client is finished.

NOTE: Acquire and release calls must be balanced. If a client releases the printer interface and does not reacquire it, Smart RIP will stay disconnected from Meteor control.

Error Handling

All OPC method calls may throw exceptions if errors occur. Check the application log file (accessible via App node's LogFile) for detailed error information.

Custom log messages can be written using the LogInfo(), LogWarning(), and LogError() methods on the App node.

Prerequisites

• Smart RIP must be running and accessible at the default OPC address: opc.tcp://localhost:26942/smartrip

• The OPC client must have appropriate certificates configured for secure communication

• At least one media file (.smd) must be available for installation

• For the Meteor node and low-level Meteor API access, the Meteor development SDK must be installed on the Smart RIP machine

Meteor Support

Smart RIP includes Meteor-specific support for customers that need low-level access to the Meteor output plugin and print engine.

This support is split across two OPC areas:

• Print.RunPluginCommand(pluginName, command) for plugin-defined commands such as GET_OUTPUT_MODE

• The Meteor node for lower-level Meteor SDK-backed control such as printer-interface ownership, signals, parameters, and status

Requirements

• The Meteor development SDK must be installed on the Smart RIP machine

• Prepare.OutputType must be set to a Meteor output type before starting the print run

• The selected media must support Meteor output

Sample Meteor media are included with SPC. These sample configurations are set up for simulated output, not a real press. That simulator setup is useful for development because it writes .sim files and allows Meteor status, controller, and plugin-command testing without real hardware.

When a Meteor print run starts, Smart RIP uses the Meteor configuration supplied by the selected media. The Meteor.Status node exposes general Meteor counters such as buffer level and print count. The Meteor.Controllers subtree is built dynamically from the active Meteor hardware configuration. Each ControllerN node contains a Heads node with one HeadN child per print head, allowing clients to inspect values such as head temperatures.

If the selected media does not support Meteor output, Smart RIP reports an error and the print run does not start.

If the selected media contains more than one Meteor configuration, Smart RIP logs a warning and uses the first one it finds.

Server/Controller/Head Tree

Smart RIP talks to one local server, so the dynamic Meteor hardware tree begins at Meteor.Controllers.

Controller Node Naming vs. Controller Numbers

Each ControllerN node (for example Controller1, Controller2) uses a numeric suffix for node uniqueness only. It does not represent the real Meteor controller ID. To identify a controller, use the ControllerNumber property inside the node.

Dynamic Changes and Node Behavior

• The ControllerCount and HeadCount properties allow clients to monitor the structure of the active Meteor system.

• These values update dynamically as controllers or heads become available, allowing OPC clients to subscribe to the corresponding nodes.

Node Dormancy and Subscription Stability

Even when the controller or head count falls:

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

• Dormant nodes stop reporting changes until they become active again.

This means OPC clients do not need to unsubscribe and resubscribe when the hardware shape changes.

Connecting to Controller Boards

Each Controller-level node represents a single Meteor controller board and contains controller state plus a Heads subtree.

The IsConnected property indicates whether the controller board is currently powered and connected to the Meteor system. It can take a short time to become true after initialization, so callers should check it periodically before relying on the controller. If one or more controllers fail to connect, clients can call Meteor.AbortBoot() to stop the boot cycle rather than waiting indefinitely.

The Meteor.Controllers.ControllerCount property reports how many controllers are defined in the active Meteor system.

The Meteor.Controllers.ConnectedControllerCount property reports how many of those controllers are currently connected.

Running from the Command Line

Smart RIP can be run directly from the command line or via a shortcut. By default, running the application will display a console window showing status and log messages. This is useful for development and troubleshooting.

In production environments, you may wish to run Smart RIP without showing the console window. There are two common approaches on Windows:

1. Using a Windows Shortcut (Minimized Window): Create a shortcut to the executable. In the shortcut properties, set the 'Run' option to 'Minimized'. This will launch the application with the console window minimized, keeping it out of the way but still accessible if needed.

2. Running Programmatically (Hidden Window): If launching from another application or script, you can use the Windows process API to start the process with the window hidden. For example, in C#:

var process = new System.Diagnostics.Process
{
    StartInfo = new System.Diagnostics.ProcessStartInfo
    {
        FileName = "SmartRip.exe",
        WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden,
        CreateNoWindow = true
    }
};
process.Start();

This will start Smart RIP without displaying the console window at all.

NOTE: The application log file will continue to record all messages regardless of window visibility. For troubleshooting, refer to the log file as described in the documentation.

Command Line Options

Run Smart RIP with the /? switch to display usage information and available command line options:

Smart RIP v1.0.0.0
Copyright © 2025 Global Graphics Software. All rights reserved.

Usage: SmartRip [/License <key>] [/Port <nnnn>] [/FactoryReset] [/?]
  /License        Activate with the specified license key
  /Port           Set the command port (default: 9999)
  /FactoryReset   Reset application settings back to the default state
  /?              Display this help

Plugin Configuration

Plugins can be configured using an optional JSON configuration placed alongside the plugin DLL file. These settings will be exposed over the OPC interface, and should be set as required prior to printing. Only Boolean values are supported at this time. The UiDisplay value is used to populate the OPC node's Description property.

Example plugin configuration file (Tiff.json alongside Tiff_Output_Plugin.dll):

{
    "Compression": {
        "Type": "Boolean",
        "DefaultValue": "False",
        "UiDisplay": [ "Compression" ]
    },

    "AddColorMapping": {
        "Type": "Boolean",
        "DefaultValue": "False",
        "UiDisplay": [ "Add Color Map" ]
    }
}

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 can be found in %programdata%\Global Graphics Software Ltd\Smart RIP\App Certificates\certs if it needs to be copied to the Trusted Peer Certificate folder.

Quick Start Example

This section provides a simple example to help first-time users connect to the Smart RIP OPC UA server and retrieve basic information. The example is written in Python, though many programming languages offer OPC UA client libraries with similar functionality.

Python Example

The following Python script demonstrates how to connect to Smart RIP and read the application version number:

# Install with: pip install opcua cryptography

from opcua import Client

# Address published by Smart RIP
SMARTRIP_URL = "opc.tcp://localhost:26942/smartrip"

# Connect to the SmartRIP OPC UA server
client = Client(SMARTRIP_URL)
client.connect()

try:
    # Navigate to the VersionNumber node
    node = client.get_node("ns=2;s=App/VersionNumber")

    # Read and display its value
    version = node.get_value()
    print(f"Smart RIP version: {version}")

finally:
    client.disconnect()

Expected Output:

Smart RIP version: Smart RIP v1.0.0.0

This example illustrates the basic pattern for OPC UA communication:

1. Connect to the server using the published endpoint address

2. Navigate to specific nodes using their NodeId (the ns=2;s=App/VersionNumber identifier)

3. Read or write values as needed

4. Disconnect properly to clean up resources

Language Support

OPC UA client libraries are available for many programming languages including C#, Java, C++, JavaScript/Node.js, and others. The concepts and workflow remain consistent across implementations, though syntax and specific API calls will vary by language and library.

Support

Application log files are stored in user-specific directories and are useful for debugging and error reporting:

Smart RIP Logs: C:\Users\[username]\AppData\Local\Global Graphics Software Ltd\SmartRip\...

MediaBridge Logs: C:\Users\[username]\AppData\Local\Global Graphics Software Ltd\MediaBridge\...

Replace [username] with the actual Windows username. These log files contain detailed information about application behavior, errors, and can be invaluable for troubleshooting issues.

Troubleshooting

This section covers common issues and solutions when working with Smart RIP via OPC UA.

• Client can't connect
  Check Smart RIP is running and port 26942 is open.

• "BadCertificate" error
  Copy the Smart RIP certificate from %ProgramData%\Global Graphics Software Ltd\Smart RIP\App Certificates\certs into your OPC client's trusted folder.

• Job fails to print
  Check the App.LogFile contents via the OPC node or local log folder.

• "BadNodeIdUnknown" error
  Verify the NodeId string is correct (e.g., ns=2;s=App/VersionNumber). Node names are case-sensitive.

• Methods throw exceptions
  Ensure prerequisite steps are completed (e.g., media installed before starting print run, job loaded before printing).

• Media installation fails
  Check the .smd file path is accessible and the file is not corrupted. Verify sufficient disk space.

• Print run won't start
  Ensure both a job file and media are specified via the Prepare node before calling PrintRunStart().

• Output files not created
  Verify the OutputPath property is set correctly and the directory exists with write permissions.

• PrintRunState stuck in 'Starting'
  Check the application log for initialization errors. Verify the selected media is compatible with the job.

• Connection timeouts
  Increase client timeout settings. Check network connectivity and firewall rules for port 26942.

• License errors
  Run SmartRip.exe /License <your-key> to activate, or contact support if the key appears invalid.

• Thumbnail generation fails or returns incomplete data
  Large thumbnails may exceed default OPC message size limits. The thumbnail is returned as a base64-encoded PNG string which can be large. Increase the OPC client message size limits as described in the Configuring Custom Message Sizes section.

• Print.StartThumbnailing(pixelSize) fails with BadInvalidArgument from Python
  Some Python OPC UA clients send numeric method arguments using a type that does not match the OPC method signature exactly. Print.StartThumbnailing(pixelSize) expects an OPC Int32 argument. If you are calling from Python, explicitly send the argument as ua.Variant(128, ua.VariantType.Int32) rather than relying on the client library to infer the type.

• Meteor methods fail with 'Print run is not active'
  Start the print run first and wait for Print.PrintRunState to become Started. Meteor methods only work during an active print run.

• Meteor methods fail because Meteor output is not active
  Check Prepare.OutputType is set to a Meteor output type before starting the print run. The Meteor node is only usable for Meteor print runs.

• Meteor print run fails to start because the selected media does not support Meteor
  Install and select media that supports Meteor output, then start the print run again.

• Smart RIP logs a warning about multiple Meteor configurations
  This means the selected media contains more than one Meteor configuration. Smart RIP will continue and use the first one it finds.

• There is no Meteor node in the OPC tree
  Check the Meteor development SDK is installed. Without the SDK, Smart RIP starts without Meteor support and does not publish the Meteor node.

• Can Smart RIP still run without the Meteor SDK?
  Yes. Customers that do not need low-level Meteor API access can still run Smart RIP. The Meteor node and other Meteor SDK-backed features will simply be unavailable.

• Meteor methods stop working after releasing the printer interface
  This is expected. ReleasePrinterInterface() hands Meteor API ownership to the external client. Call AcquirePrinterInterface() to give control back to Smart RIP before using the Meteor node again.

• Meteor status is not updating
  Check Meteor.IsRouterConnected and Meteor.IsPrinterInterfaceAcquired. If the interface has been released to client code, Smart RIP stops polling Meteor until it is acquired again.

• Meteor.Status.PdCount does not increment while using .sim output
  This is expected. The Meteor simulator does not model real hardware product-detect counting.

For detailed diagnostic information, always check the Smart RIP application log accessible via the App.LogFile node or the local log directory.

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 Smart RIP.

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 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.

SmartRIPSet

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.

App

State relating to the entire application.

Details

The App node is the entry point for OPC clients and exposes basic application-wide functionality.

This node exposes methods and data for:
- Retrieving version information.
- Reading the application log file.
- Writing messages to the application log.
- Requesting application shutdown.

Properties

Methods

Files

NOTE OPC File nodes contain functions which allow access to file content:

• Open(int fileAccess) - Open the file with the specified fileAccess (1:read, 2:write), returning an integer file handle.

• Read(int fileHandle, int length) - Read data from an open file handle, returning an array of bytes.

• Write(int fileHandle, byte[] buffer) - Write/append data to an open file handle.

• Close(int fileHandle) - Close the file handle after use.

For more information see the OPC documentation.

Controllers

State relating to the collection of head controllers.

Properties

Media

State relating to the application media library.

Details

The media sub-tree provides mechanisms to manage a library of 'media' configurations.
A media defines the printer settings, color adjustments, etc. required to correctly print on a particular physical media type.

Media are stored in .smd files on disk.

The media library supports installation from both server-accessible media files (InstallMediaFromPath()) and client-only media files (InstallMediaFileChunk()).
In both cases a copy of the media file is taken.

Installing a media with the same name as an existing media file will result in the latter being replaced.

Properties

Methods

Meteor

Meteor-specific control and status for the active print run.

Details

The Meteor node exposes low-level Meteor methods for customers that need direct access to the Meteor plugin and print engine.

These methods are only available while a Meteor print run is active.

Use this node for Meteor-native operations such as printer-interface ownership, signal and parameter updates, device queries, and controller/head telemetry.

If the printer interface is released to an external client, Smart RIP stops making Meteor API calls until the interface is acquired again.

Properties

Methods

PluginOptions

Collection of plugin-specific configurable options.

Details

Each plugin can have its own JSON configuration file defining custom values that will be exposed as dynamic OPC properties.

Prepare

State relating to the job to print.

Details

The Prepare node is used by clients to configure the printer with data and settings for a job.

This node exposes properties and methods for:
- Uploading job file data either in chunks or from a file system path.
- Setting copy count and other job ticket properties.

Clients must complete the job configuration before initiating printing.

NOTE: All requests to modify the configuration are locked once a print run becomes active.

Properties

Methods

Print

State relating to the process of printing.

Details

The Print node is used by clients to perform and monitor a print job.

This node exposes properties and methods for:
- Starting and stopping print runs.
- Submitting jobs for printing.
- Sending plugin-specific commands while a print run is active.
- Monitoring job progress.

All job configuration must be completed through the Prepare node before initiating printing.

Properties

Methods

Status

State relating to the Meteor status data of the active print run.

Details

The status values are automatically updated on a regular basis while Smart RIP owns the Meteor printer interface.

Properties

Glossary