What Is LumiScan Keryx?

LumiScan Keryx is the data backbone of the LumiScan vision apps. Every app puts its values, functions and results into one tree of named nodes, and everything else - a PLC, a SCADA system, your own program, a test script, the people commissioning the cell - reaches them at one address. Nothing is wired point to point.

The name comes from the Greek kēryx, the herald: the messenger who carries news between the parties.

LumiScan Keryx connects the apps that provide data with everyone who uses it
%% LumiScan Keryx - concept. Rendered by Mermaid in the browser; edit and preview at https://mermaid.live
flowchart LR
  subgraph users["Who uses the data: read · write · call · subscribe"]
    plc["`**PLC or SCADA**
    through the OPC UA Connector`"]
    prog["`**Your program**
    C++, Python or OPC UA`"]
    tests["`**Scripts and tests**
    krxclient`"]
    people["`**People**
    Keryx page, Cockpit`"]
  end
  keryx["`**LumiScan Keryx**
  the broker, one address for all:
  tcp://127.0.0.1:5555

  one tree of named, typed nodes:
  hdvisionsystems/lumiscan-cam-driver/camera1/...`"]
  subgraph apps["Who provides it: register nodes · publish"]
    cam["`**Cam Driver**
    camera images`"]
    ai["`**AI Object Matching**
    neural networks`"]
    find["`**Finders and readers**
    parts, codes, text`"]
    calib["`**Calibration**
    pixels to 3D`"]
    own["`**Your own function**
    C++ or Python`"]
  end
  plc & prog & tests & people <--> keryx
  keryx <--> cam & ai & find & calib & own
  class keryx key
  classDef key fill:#faf6dc,stroke:#a8961f,color:#1f2328

Why Keryx

In a vision project, the image processing is only part of the work. The rest is getting it into the machine: a handshake with the PLC, a result format the PLC can read, a live view, a way to find out why a part was rejected, and tests without the real line. Without a common backbone this is built again for every project and every customer.

Keryx does this work once, for all LumiScan apps:

  • every app offers its functions in the same way, at addresses built by the same rules;

  • a PLC, a program or a person uses all apps through one connection;

  • adding a second camera or another app means adding one more participant, not rewiring the cell.

The concept

One tree of nodes

Everything on Keryx is a node with an address, written like a file path:

hdvisionsystems/lumiscan-cam-driver/camera1/control/capture/execute

A node is a value (a number, a flag, a text, an image), a function you can call, or a folder that groups other nodes. Every node describes itself: what it is, its type, and whether it may be read, written, called or subscribed to. So a client can browse the tree and find out what an app offers without a separate interface description - in the same way as an OPC UA server.

The addresses follow one scheme in every app: <app>/<module>/control/…​ for the functions, input/…​ for what you write before a call, output/…​ for the results. See Addresses and Modules.

Providers, clients and the broker

Role What it does

Provider

an app that serves nodes: it registers them and publishes changes. The Cam Driver, AI Object Matching, the finders, the readers and Calibration are providers.

Client

anyone who reads, writes, calls or subscribes: a PLC, your program, krxclient, the Keryx page, Cockpit - and an app that uses another app’s results.

Broker

the one program everybody connects to (krxsystem). It holds the tree and routes every request to the provider of the node. On a PC there is one broker, at tcp://127.0.0.1:5555; the first app that needs it starts it, and the apps start it again if it stops.

Gateway

a client that makes the tree available over another protocol. The OPC UA Connector shows the whole tree as an OPC UA server, so that any PLC or SCADA system with an OPC UA client can use the apps.

Three ways to call a function

How a function is called depends on how long it takes:

Pattern Use it for

Execute

work that is done within about a second: one write, answered when the work is finished. Example: take an image.

Handshake

work that can take longer: the client sets request, the app answers through ready - the pattern every PLC programmer knows. Example: connect a camera.

Stream (experimental)

continuous work: subscribe once and receive every result. Example: every camera frame goes to AI Object Matching, and every detection to your program.

Most functions of the Cam Driver, AI Object Matching and Calibration are offered in more than one pattern, with one implementation behind them: the result is the same. See Choosing a Pattern.

The same on ctrlX OS and on a PC

On a PC with Windows 11 or Ubuntu 24.04 the apps use the Keryx broker. On ctrlX OS they use the ctrlX Data Layer instead. The addresses, types and call patterns are the same on both, so a PLC program or an application written for one works with the other. See ctrlX Data Layer and LumiScan Keryx.

What it gives you

Decision makers and project leads

  • Less engineering per project. The connection to PLC, live view and test tools is part of the product, not built again for every cell.

  • Standard interfaces, no lock-in. Keryx follows the interface of the ctrlX Data Layer; towards the machine it speaks OPC UA; structured results use FlatBuffers, an open format with a published schema.

  • Modular. Each function is its own app. Add a camera or an app, or replace one, without touching the others.

  • One design for two platforms. The same apps and the same integration run on a ctrlX CORE and on a Windows or Linux PC.

PLC programmers and system integrators

  • Familiar patterns. Long operations are a ready/request handshake; short ones a single call.

  • Plain values for the PLC logic. Status codes, counts, positions and texts are plain variables. Full results are available as structured data with their schema.

  • Any PLC with OPC UA. On a PC, the OPC UA Connector shows every node as an OPC UA node; its NodeId is the Keryx address. On ctrlX OS, the ctrlX PLC reads the nodes directly.

  • Apps work together without the PLC in between. By stream, the camera feeds AI Object Matching, and its results go to Calibration; the PLC only reads the final result.

Commissioning and service

  • See everything. The Keryx page shows the whole tree: every value, its type and permissions. Write values, call functions and watch values change - without a PLC and without writing code.

  • Every module says how it is. control/status/code and control/status/text tell what the last operation did and why it failed. See Status Codes and Results.

  • It keeps running. Each app is a process of its own: one app that stops takes no other app with it. If the broker stops, it is started again within seconds, and the apps reconnect by themselves.

  • Results explain themselves. Every stream result names the camera and frame it came from, the modules it passed and the settings they used - so a rejected part can be traced back to its image.

Software developers

  • No SDK needed to use the apps. Any OPC UA client library, in any language, reaches every function. For scripts and tests there is the command line client krxclient. See Tools.

  • Test each step alone. Call one function once, check its output, and only then chain the steps.

  • Self-describing. Browse the tree to find nodes; the schemas of structured results are on the tree itself, under types/hdvisionsystems/<app>/…​.

  • Bring your own function. Algorithms and devices can be added as providers of their own, in C++ or Python, next to the LumiScan apps. Ask HD Vision Systems for the developer package.

IT and security

  • Closed by default. The broker accepts connections from the same PC only (127.0.0.1), and so does the Keryx page. Opening it to a network is a deliberate setting.

  • No cloud. Keryx runs entirely on the machine; it needs no internet connection.

  • Control at the edge. The OPC UA Connector can serve one part of the tree only, and can run read-only. On ctrlX OS, the apps use the ctrlX Data Layer with the user management of ctrlX OS.

The Keryx broker and the OPC UA Connector have no authentication and no encryption today. Run them on one PC, or in a separate machine network you trust, behind a firewall. See OPC UA Connector: Security.

Good to know

  • One broker per PC. All apps of one installation use the same broker. Several brokers on different ports are independent of each other; brokers on several PCs do not share one tree.

  • Values carry no timestamp of their own. An app that needs one publishes it in a node or inside the result.

  • A new subscriber gets no initial value. Read the node once, then subscribe.

  • Streams are experimental in the current releases.

More in LumiScan Keryx on a PC: Good to know.

Where to go next