---
title: "Addresses and Modules"
description: "How the Data Layer addresses of the LumiScan apps are built - apps, modules, the folders control, input, output and setting, the system node, module names and the layout of each app."
product: "LumiScan Keryx"
component: "lumiscan-keryx"
version: "1.0.0"
display_version: "1.0.0.7"
latest_version: true
language: "en"
url: "https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/addresses.html"
---

# Addresses and Modules – LumiScan Keryx

## The address of a node

```none
hdvisionsystems/<app>/<module>/<folder>/...     the nodes of one module
hdvisionsystems/<app>/system/...                what concerns the whole app, or more than one module
types/hdvisionsystems/<app>/<type>              the FlatBuffers types the app publishes
```

- **`<app>`:** The app’s name on the Data Layer, lower case with `-`, for example `lumiscan-cam-driver`. It is not always the name of the program: the program `lumiscan-ai-obj-mat` serves `lumiscan-ai-object-matching`, and `lumiscan-calib` serves `lumiscan-calibration`.
- **`<module>`:** One instance inside the app: a camera, a neural network, a calibration plane, a finder module. Its name comes from the app’s settings. The code readers have no module level.

Example: `hdvisionsystems/lumiscan-cam-driver/camera1/control/connect-camera/request`.

## Module names {#module-names}

- Addresses are **lower case**. A node you cannot find is nearly always a difference in case or spelling.
- Module names consist of lower-case letters, digits, `-` and `_`. The Cam Driver and AI Object Matching refuse any other module name: such a module does not appear on the Data Layer. Calibration names a module after its file and uses the name in lower case.
- `system` is reserved and is never a module name.

## The folders of a module {#folders}

| Folder | Holds |
| --- | --- |
| `control/` | the functions: `control/<function>/ready` and `request` (a [handshake](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/handshake.html)), `control/<function>/execute` (an [execute method](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/execute.html)); the module’s status `control/status/code` and `control/status/text`; the [streams](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/streams.html) `control/publish/`, `control/subscribe/` and `control/unsubscribe/` |
| `input/` | what a client writes before it starts a function |
| `output/` | the results of the functions, read-only |
| `setting/` | a read-only view of what the module applies, for example `setting/settings-hash` and `setting/stream/…` |

Some apps have folders of their own, for example the Cam Driver’s `device-info/`, `transport-layer/` and `features/`.

## Where a function keeps its nodes {#layout}

**An execute method** keeps everything it owns under its function:

```none
<module>/control/<function>/execute
<module>/control/<function>/input/...
<module>/control/<function>/output/...
```

**A handshake** has `ready` and `request` under its function, and uses the inputs and outputs of the module:

```none
<module>/control/<function>/ready
<module>/control/<function>/request
<module>/input/...
<module>/output/...
<module>/control/status/code, text
```

**A function that has both** - most functions of the Cam Driver, AI Object Matching and Calibration - uses the module’s `input/` and `output/` for both ways of calling it.

## The layout of each app {#layouts-per-app}

Some apps keep an older layout so that programs written against them keep working.

| App | Module named by | Functions |
| --- | --- | --- |
| Cam Driver | `id` in the module file | `<module>/control/<function>/…` |
| AI Object Matching | `name` in the module file, `default` if none | `<module>/control/<function>/…` |
| Calibration | the module file’s name without `.json` | `<module>/control/<function>/…` |
| Template Finder, Object Finder, Area Detector, Text Reader | the module id given to `system/create-module`, or the saved module list; `module-1` by default | `<module>/<method>/execute`, `<module>/<method>/input/…`, `<module>/<method>/output/…`, for example `module-1/find-template/execute`; streams under `<module>/control/` |
| DMC, QR, Aztec and Barcode Reader | no module level | `<app>/execute`, `<app>/input/…`, `<app>/output/results`; streams under `<app>/control/` |
| Cockpit | none: Cockpit only reads the nodes of the other apps |   |

The exact nodes of each app are in its manual’s **Data Layer Reference**.

## The system node {#system}

Everything that is not about one module is under `hdvisionsystems/<app>/system/`: making and removing modules, the settings files, device discovery, and resources shared by all modules. The code readers have only `system/meta/subscription-schema` there. See [Settings, Modules and Restart](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/settings-and-modules.html).

## Types {#types}

| Type | Used for |
| --- | --- |
| bool, int16, int32, uint32, uint64, float32, float64, string | plain values: inputs, flags, counters, status codes (`int32`) |
| arrays of these | for example the coordinate arrays of Calibration |
| FlatBuffers | results and images. Their schemas are on the Data Layer under `types/hdvisionsystems/<app>/…` |

Build PLC logic on the plain values. A FlatBuffers result needs its schema to be decoded; every result a PLC usually needs is also available as plain nodes - see the app’s manual.