User Guide (SmartRIP)

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.

• 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

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() on the Print node.

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:

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

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>] [/?]
  /License        Activate with the specified license key
  /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.

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.

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

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.

• Monitoring job progress.

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

Properties

Methods

Glossary