Pathfinder Core PRO can emulate other routing systems. This is useful if you need to interface with an automation system that has not implemented any of the protocols that drive Axia routing systems.
Click the Devices > Device Emulators link in the navigation bar to display the list of device emulators currently defined in the system.

Column | Notes |
|---|---|
Name | The name of the emulator. |
Type | The type of the emulator (Generic Emulator, Probel General Router, Probel General Switcher, Probel General Router Silence). |
Connection Type | The connection type to be used with the emulator. |
Details | The state of the port and how many clients are connected. For TCP connections, the circle is a recycle button that drops and reopens the emulator's connections. |
Port | The Port used for the connection. |
Click edit to modify the associated emulator’s properties. Click the trash icon to remove the associated emulator. Click Add + to add a new emulator. Pathfinder Core PRO currently supports four types of device emulation, each with slightly different configuration options.
Creating a Generic Emulator
Click Add + on the Device Emulators page to create a new emulator.
Type a unique Name for this emulator and select Generic Emulator from the Emulator Type drop-down list.

Complete the Connection Settings. The Generic Device Emulator is a TCP/UDP connection that can be used to send and receive custom messages from an automation system or some other third-party system.

Field | Description |
|---|---|
Connection Type | From the drop-down list, select either TCP/UDP Listener or TCP/UDP Client, depending on whether the system using this emulator will establish the connection to Pathfinder Core PRO (an inbound connection—select TCP/UDP Listener) or Pathfinder Core PRO should initiate the connection to the other device (an outbound connection—select TCP/UDP Client). |
Port | If the other device is initiating the connection to Pathfinder Core PRO (Pathfinder Core PRO is the TCP/UDP Listener), type the port on which Pathfinder Core PRO will listen for the connection. If Pathfinder Core PRO needs to initiate and maintain the connection (Pathfinder Core PRO is the TCP/UDP Client), type the IP address and port of the device to which Pathfinder Core PRO should connect. |
Important Note: Pathfinder Core PRO does not currently support serial ports. If you need serial port control, investigate serial-to-TCP converter solutions, or use Pathfinder’s Port Router application to bridge the serial data to TCP data.
Type your initialization message in the Init Message field. This message is sent when this Generic Emulator connects, which allows the emulator to automatically send login or other initialization messages, including special escape characters (see the Escape Characters section later in this chapter). For Listener types, this message is sent to each client that connects to the listener. For Client connection types, this message is sent each time the client connects. Generic Device Emulators have a write-only property called ToSend that Logic Flows can use. This property lets you create a flow that sends any kind of data you wish out of the Generic Emulator.
For a TCP Client, you can also set a Success Message and a Wait Time (ms). If the reply to the Init Message does not contain the Success Message within the Wait Time, the emulator drops the connection and tries again. Leave the Success Message blank to skip this check.

Generic emulators also have optional Ping Message and Ping Interval fields.
If you are using a TCP client and want to make sure the connection is still alive, a periodic ping can force the network to check it. If the PingMessage is blank, this feature is not used.
When a remote device closes its TCP connection normally, a handshake takes place that tells the emulator the connection has been closed. The emulator then tries to re-establish the connection. However, if the remote device loses power or the connection dies in a way that does not allow the handshake to take place, the emulator will not know the connection is dead until either an operating system keepalive packet fails (which might take up to an hour or two) or the emulator tries to send a message to the remote device.
The ping message and ping interval allow you to define a message that is sent at a regular interval to make sure the connection is still working. The message should be one that the application on the remote end understands.
The ping also lets you test not only that the connection is still intact but that the application at the remote end is still responding. It may still take longer than the interval time to detect a failure (often 15 to 60 seconds). Therefore, do not set the interval too low.
A Generic Device Emulator can trigger actions based on incoming data. To define these actions, create Watchers. Each Watcher looks for data coming in to the emulator port and, when it sees that data, briefly sets the Watcher’s Triggered property to True. To create a new Watcher, click the Add button and select the newly created Watcher from the list.

Buffer Max limits how many bytes of incoming data are kept while looking for a match.
With the new Watcher selected, type a Name for this Watcher and the Value to watch for in the Name and Value fields directly below the Watcher list.
You can edit an existing Watcher by clicking the Watcher entry in the list and updating the values in these Name and Value fields.
When all fields are complete, click Apply to save your changes and create the Emulator.
Escape Characters
Both the ToSend properties and the Watcher values support several escape sequences that represent special characters:
Escape Sequence | Character |
|---|---|
| Carriage Return |
| Line Feed |
| Tab |
| Used to un-escape an escape |
| Hex value where XX is a two-character hex value for the character to send or receive. |
Therefore, a Watcher that is watching for MyName\cr\lf is looking for the string “MyName” followed by a carriage return and line feed.
Double slashes, as in MyName\\cr\\lf, are converted to a single literal slash. Use them when you actually want to send the value \cr\lf.
Using Watchers in Logic Flows
The Name of the Watcher identifies the Watcher in the system and appears as an object underneath the Emulator in the Logic Flows property selection tree.

In the example above, we have created a Watcher on this device emulator named Hello, and it is watching for the value Hello. When we see the word “Hello” come into this emulator, the Watcher’s momentary Triggered property will be set to True and then reset to False until the next time the value “Hello” is registered.
We can create a Logic Flow where the Start Point is the Triggered property of the Watcher and do anything we like in the system when we see the string “Hello” come in through the Device Emulator port.

In this Logic Flow, every time we see the string “Hello” on the Watcher, we pulse GPO port 2 pin 4 low.
Additional Emulator Properties for Logic Flows
Additional properties related to Generic Emulators that may be used in Flows include:
Connected – This property will be True if there are any clients connected or if the TCP client is successfully connected and False otherwise
ConnectedCount – This property holds the number of clients currently connected to the emulator
ConnectionLost – This property will switch to True and then back to False when a client disconnects
ConnectionObtained – This property will switch to True and then back to False each time a client connects
LastReceived and LastSent – The last data the emulator received and sent
InitMessage, PingMessage and PingInterval – The emulator's settings, so a Logic Flow can change them
Each Watcher has:
Triggered – Switches to True and back to False each time the Watcher's value is found
FoundCount – How many times the value has been found
WatchValue – The value the Watcher looks for, so a Logic Flow can change it
TriggeredValue – When the Watcher input is discovered, that value will be assigned to the TriggeredValue property momentarily and then the value will be set back to blank. It is momentary so that a change is raised each time the same value enters the emulator
Watchers and Regular Expressions
Generic Device Emulator Watchers also support the use of regular expressions or Regexes. Pathfinder Core PRO uses the Microsoft .NET variation of regular expressions—an advanced language used for pattern matching in text.
Regular expressions parse the Watcher’s input relative to the regular expression pattern, tripping the Watcher’s Triggered property to True when there is a match. Pathfinder Core PRO Watchers use two forms of regular expressions:
Regex.Match(<expression_pattern>)Regex.IsMatch(<expression_pattern>)
To add a regular expression to a Watcher, type the RegEx statement in the Watcher Value field, as in the SongTitle Watcher above (Regex.Match(TITLE=(.*))).
Regex.Match Method
Regex.Match evaluates Watcher input against the expression and sets the Triggered property to True when it matches. However, because a Regex can be used to match multiple different chunks of text, it is often also useful to have the exact chunk of text that was matched available to a Logic Flow. That is where the TriggeredValue property comes in.
A Value such as Regex.Match(..ll.) matches any series of five characters where the third and fourth characters are l.

Watcher inputs like Yello, Hello, Mello, hhlll and hhllh will trip the Watcher’s Triggered property to True and allow the TriggeredValue property to pass the input value that resulted in the match.
.png?sv=2026-02-06&spr=https&st=2026-11-22T15%3A54%3A39Z&se=2026-11-22T16%3A15%3A39Z&sr=b&sp=r&sig=3uGVCQGhdVLclPTNuow3USx7%2BE5XHfpOof8V%2Bb8xyYA%3D)
As another example, to extract a duration from a satellite message such as "CBS050", we could use this regular expression in the Watcher’s Value field:
Regex.Match((?<=CBS).{3})
This Regex would set the Watcher’s Triggered property to True any time it sees six characters where the first three are CBS and allow the TriggeredValue property to pass only the three characters that follow the CBS. In this example, the TriggeredValue property would equal 050. This expression makes use of the look-behind assertion of regular expressions.
A different Watcher could then be created for a different show from the same Emulator.
Regex.Match((?<=NBC).{3})
Regex.IsMatch Method
Regex.IsMatch() performs a similar function, except that rather than passing the value of the match, the TriggeredValue will output True if a match exists. This makes the method largely redundant, since a match will also set the Triggered property to True, but there are times when this method can be useful in Logic Flows as discussed below.
Special Characters
Carriage returns and line feeds must be considered when the incoming data is a line‑based protocol. Failing to properly account for these special characters when parsing incoming data will cause incorrect results.
If your Watcher input will include carriage returns and line feeds at the end of each message, you could use something like (.\r\n) or ((?s).). The latter uses single-line mode.
Escape Sequence | Character |
|---|---|
| Carriage Return |
| Line Feed (new line) |
| Tab |
| Escape |
Modifying Default Behavior
Several options can be used within the expression to change how the pattern matcher works. For example, by default, the dot or period character ( . ) matches any character except the new line. If you want it to match the new line character as well, you can enable the single-line option to modify the function of the wildcard within the pattern matcher:
Regex.Match((?s).*)
The inline ?s modifies the regular expression engine to use the single-line option when analyzing.
Or you could use the space or no space option to match any character including carriage returns and line feeds:
Regex.Match([\S\s]*)
These modifying options are documented here:
https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-options
Regular expressions are extremely advanced and can appear to be very complicated. One joke about regular expressions is that once you solve a problem with a regular expression you now have two problems. However, they can also be very powerful for the situations where they are needed.
They are part of one of the most commonly used and advanced text pattern matching and manipulation languages across all programming languages used today. However, they will also be slower and more CPU-intensive than the normal matches Pathfinder Core PRO performs because they have not been optimized at compile time in the same way as the native code. This is one reason to use them sparingly and with caution. Use them only when you need them and not when Pathfinder Core PRO’s inherent pattern matching is a better option.
Also, test thoroughly. It is quite easy to design a regular expression that you think is correct but misses certain edge cases. The regex tester listed in the links below can be very useful in this case.
Again, this is an advanced feature, and incorrect use can cause unpredictable results. But it is also a very powerful tool for certain situations.
Learn more about regular expressions using these links:
Probel General Router and General Switcher
Pathfinder Core PRO supports two Probel routing protocols: Probel General Router and Probel General Switcher. The syntax of these protocols is different, so consult the automation system’s manual to find out which protocol to use.
In both cases, the protocol provides routing control. As a result, after selecting this protocol type, the web page will present a drop-down list with the available routers so that you can choose which router the Emulator will control.
Click Add + on the Device Emulators page to create a new emulator.
Type a unique Name for this emulator and select either Probel General Switcher or Probel General Router from the Emulator Type drop-down list.
Complete the Connection Settings.

Field | Description |
|---|---|
Connection Type | From the drop-down list, select either TCP Listener or TCP Client, depending on whether the system using this emulator will establish the connection to Pathfinder Core PRO (an inbound connection—select TCP Listener) or Pathfinder Core PRO should initiate the connection to the other device (an outbound connection—select TCP Client). |
Port | If the other device is initiating the connection to Pathfinder Core PRO (Pathfinder Core PRO is the TCP Listener), type the port on which Pathfinder Core PRO will listen for the connection (a Probel General Router listener also accepts a comma-separated list of ports). If Pathfinder Core PRO needs to initiate and maintain the connection (Pathfinder Core PRO is the TCP Client), type the IP address and port of the device to which Pathfinder Core PRO should connect. |
Type Matrix and Level values, and select a Router from the drop-down list. When all fields are complete, click Apply to save your changes and create the Emulator.
Probel General Router Silence
The Probel General Router Silence type is a Probel General Router that also reports silence on the routed audio to the automation system.

In addition to the Probel fields, it has AlarmTime and ReleaseTime (ms), AlarmChannels (Any, All, Left or Right) and MonitorLevel (which Probel level, or Any or All, is watched). These work like the settings of an audio alarm (see the Audio Alarms article).