IoT-Driver.OmronPlcRx.Reactive 1.0.2

.NET 8.0 .NET Framework 4.6.2

dotnet add package IoT-Driver.OmronPlcRx.Reactive --version 1.0.2

NuGet\Install-Package IoT-Driver.OmronPlcRx.Reactive -Version 1.0.2

This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.

<PackageReference Include="IoT-Driver.OmronPlcRx.Reactive" Version="1.0.2" />

For projects that support PackageReference, copy this XML node into the project file to reference the package.

<PackageVersion Include="IoT-Driver.OmronPlcRx.Reactive" Version="1.0.2" />
                    

                            Directory.Packages.props

<PackageReference Include="IoT-Driver.OmronPlcRx.Reactive" />
                    

                            Project file

For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package.

paket add IoT-Driver.OmronPlcRx.Reactive --version 1.0.2

The NuGet Team does not provide support for this client. Please contact its maintainers for support.

#r "nuget: IoT-Driver.OmronPlcRx.Reactive, 1.0.2"

#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.

#:package IoT-Driver.OmronPlcRx.Reactive@1.0.2

#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package.

#addin nuget:?package=IoT-Driver.OmronPlcRx.Reactive&version=1.0.2
                    

                            Install as a Cake Addin

#tool nuget:?package=IoT-Driver.OmronPlcRx.Reactive&version=1.0.2
                    

                            Install as a Cake Tool

The NuGet Team does not provide support for this client. Please contact its maintainers for support.

OmronPlcRx

Overview

OmronPlcRx is a typed, reactive .NET driver for Omron FINS over TCP, UDP, Host Link FINS serial, and Toolbus serial. Register a PlcTag<T>, address it through a LogicalTagKey<T>, then read, write, or observe it. The base package uses ReactiveUI.Primitives; OmronPlcRx.Reactive is the equivalent System.Reactive-oriented surface. Both are shared-source builds.

The public namespaces are IoT.Driver.OmronPlcRx and its .Core, .Core.Types, .Enums, .Results, .Tags, and .Async children. The reactive package replaces the root with IoT.Driver.OmronPlcRx.Reactive.

Safety

PLC writes can change machinery state. Validate addresses, types, interlocks, ownership, and the target controller in a non-production environment first. Subscribe to Errors, use cancellation tokens and bounded timeouts, and prefer WriteValueAsync when a command must be observed. SetValue queues a background write; failures are reported through Errors rather than returned to the caller.

Package matrix

Package	Use
`IoT-Driver.OmronPlcRx`	Base API using ReactiveUI.Primitives and BCL `IObservable<T>`.
`IoT-Driver.OmronPlcRx.Reactive`	Same driver shape for System.Reactive consumers; namespaces end in `.Reactive`.
`IoT-Driver.OmronPlcRx.Generators`	Standalone Roslyn generator package.

All runtime packages target net462, net472, net481, net8.0, net9.0, net10.0, and net11.0.

Install

dotnet add package IoT-Driver.OmronPlcRx
# Or, for System.Reactive applications:
dotnet add package IoT-Driver.OmronPlcRx.Reactive
# Add separately when using source-generated bindings:
dotnet add package IoT-Driver.OmronPlcRx.Generators

Quick start

The public network constructor takes OmronConnectionOptions and an explicit nullable poll interval.

using IoT.Driver.Core;
using IoT.Driver.OmronPlcRx;
using IoT.Driver.OmronPlcRx.Enums;
using IoT.Driver.OmronPlcRx.Tags;

var motorRun = new PlcTag<bool>("MotorRun", "D100.0");
var temperature = new PlcTag<short>("Temperature", "D200");
var options = new OmronConnectionOptions(11, 1, ConnectionMethod.UDP, "192.168.250.1")
{
    Port = 9600,
    Timeout = 2000,
    Retries = 1,
};

using var plc = new OmronPlcRx(options, TimeSpan.FromMilliseconds(200));
plc.AddUpdateTagItem(motorRun);
plc.AddUpdateTagItem(temperature);

var motor = new LogicalTagKey<bool>("MotorRun");
using var subscription = plc.Observe(motor).Subscribe(value => Console.WriteLine(value));

await plc.WriteValueAsync(motor, true, CancellationToken.None);
short? value = await plc.ReadValueAsync(new LogicalTagKey<short>("Temperature"), CancellationToken.None);

Configuration

Create OmronConnectionOptions(localNodeId, remoteNodeId, connectionMethod, remoteHost). Its init-only settings are Port (9600), Timeout milliseconds (2000), Retries (1), and optional SerialOptions.

For serial, use the dedicated constructor and supply every parameter:

using IoT.Driver.OmronPlcRx;

var serial = OmronSerialOptions.CreateToolbus("COM3");
using var plc = new OmronPlcRx(11, 0, serial, 2000, 1, TimeSpan.FromMilliseconds(250));

OmronSerialOptions defaults to Host Link FINS (9600, 7E2, no handshake). CreateToolbus sets Toolbus, 115200, 8N1, and RTS. Call Validate() before connecting when options are composed dynamically. Host Link supports Direct and Network OmronHostLinkFinsFrameMode values; classic C-mode Host Link is not the API exposed by this driver.

FINS addresses supported by the typed tag codec include bit forms such as D100.0 and word forms such as D200; strings use D600[20]. Use a tag type matching PLC storage: bool, integer types, float, double, string, and Bcd16, BcdU16, Bcd32, or BcdU32.

Detailed features

Typed tags, polling, and fault handling

ObserveAll emits changed IPlcTag instances and Errors emits OmronPLCException. Use a logical key whose type exactly matches the registered tag.

using IoT.Driver.Core;
using IoT.Driver.OmronPlcRx.Tags;

var level = new PlcTag<float>("TankLevel", "D400");
plc.AddUpdateTagItem(level);

using var changes = plc.ObserveAll.Subscribe(tag =>
    Console.WriteLine($"{tag?.TagName}: {tag?.Value}"));
using var errors = plc.Errors.Subscribe(error => Console.Error.WriteLine(error?.Message));

var levelKey = new LogicalTagKey<float>("TankLevel");
plc.SetValue(levelKey, 12.5f);                 // fire-and-forget
await plc.WriteValueAsync(levelKey, 12.5f, CancellationToken.None); // awaited command
float? cached = plc.GetValue(levelKey);
bool removed = plc.RemoveTagItem("TankLevel");

Clock and scan-time operations

var clock = await plc.ReadClockAsync(CancellationToken.None);
Console.WriteLine(clock.Clock);

await plc.WriteClockAsync(DateTimeOffset.UtcNow, CancellationToken.None);
var cycle = await plc.ReadCycleTimeAsync(CancellationToken.None);
Console.WriteLine($"min={cycle.MinimumCycleTime}, max={cycle.MaximumCycleTime}");

ReadClockResult, WriteClockResult, ReadCycleTimeResult, ReadBitsResult, ReadWordsResult, WriteBitsResult, and WriteWordsResult expose transport counters, duration, and their operation-specific payload.

Async observation and simulation

OmronPlcRxAsyncObservableExtensions provides ObserveAsAsyncObservable, ObserveAllAsAsyncObservable, ErrorsAsAsyncObservable, and ObserveValuesAsync. Use OmronPlcSimulator for deterministic application tests: construct it, Seed(tag, value), optionally QueueFault, then exercise the same IOmronPlcRx API. It records OmronSimulatorOperationRecord values in Operations.

Source-generated bindings

After installing IoT-Driver.OmronPlcRx.Generators, apply PlcTagAttribute to a field in a partial class. The analyzer generates registration, observation, and optional write helpers. Its configurable members are TagName, Register, Observe, and Writable; PlcTagBindingAttribute marks a binding target. Treat generated member names as analyzer output and keep the containing type partial.

Exhaustive feature guide and worked workflows

The driver uses a definition (PlcTag<T>) and a lookup key (LogicalTagKey<T>). A definition has a logical TagName and FINS Address; a key contains only the logical name and must use the same T. This makes wrong address/type combinations visible at registration rather than allowing untyped strings to flow through every command. The reactive package has the same shape beneath IoT.Driver.OmronPlcRx.Reactive; do not mix base and reactive tag/key types.

Network constructors, serial constructors, and options validation

OmronConnectionOptions is the network constructor input: local node ID, remote node ID, ConnectionMethod.TCP or UDP, remote host, optional port, timeout, retry count, and optional serial options. Its values are immutable after construction except through the initializer, so build and validate it before creating a long-lived client. The serial constructor takes (localNodeId, remoteNodeId, OmronSerialOptions, timeout, retries, pollInterval). pollInterval is nullable: provide a positive interval for automatic tag polling; use null only when the application performs direct reads deliberately.

using IoT.Driver.OmronPlcRx;
using IoT.Driver.OmronPlcRx.Enums;

var options = new OmronConnectionOptions(11, 1, ConnectionMethod.TCP, "192.168.250.1")
{
    Port = 9600,
    Timeout = 2_000,
    Retries = 2,
};

using var plc = new OmronPlcRx(options, TimeSpan.FromMilliseconds(250));

var serialOptions = OmronSerialOptions.CreateToolbus("COM3");
serialOptions.Validate();
using var serialPlc = new OmronPlcRx(11, 0, serialOptions, 2_000, 1,
    TimeSpan.FromMilliseconds(250));

OmronSerialOptions models COM port, baud rate, data bits, parity, stop bits, handshake, Host Link unit number, response wait, maximum frame length, protocol, and Host Link FINS frame mode. The default is Host Link FINS at 9600 7E2. CreateToolbus changes the protocol and standard Toolbus framing (115200 8N1 with RTS). HostLinkFinsFrameMode.Direct is direct CPU framing; Network carries the full routed FINS header. Validate() throws for invalid combinations before a connection is attempted; communication/PLC errors arrive as OmronPLCException through Errors or from awaited calls.

Addressing, supported values, BCD, and codec behaviour

Use FINS addresses with the data area prefix: D100.0 is one data-memory bit, D200 one word, and D600[20] a string region. Match the tag generic type to the physical storage. Supported codecs include bool, signed/unsigned integral types, float, double, string, and Bcd16, BcdU16, Bcd32, BcdU32. BCD wrappers state that a value is decimal packed BCD rather than a normal signed binary integer; construct them from the logical numeric value. BCDConverter is the explicit conversion utility when an application must inspect raw BCD words. MemoryBitDataType and MemoryWordDataType describe areas used by lower-level FINS operations, while PlcType is detected controller metadata.

using IoT.Driver.Core;
using IoT.Driver.OmronPlcRx.Core.Types;
using IoT.Driver.OmronPlcRx.Tags;

plc.AddUpdateTagItem(new PlcTag<bool>("PumpEnabled", "D100.0"));
plc.AddUpdateTagItem(new PlcTag<int>("BatchCount", "D300"));
plc.AddUpdateTagItem(new PlcTag<string>("RecipeName", "D600[20]"));
plc.AddUpdateTagItem(new PlcTag<Bcd16>("TemperatureBcd", "D700"));

var bcdKey = new LogicalTagKey<Bcd16>("TemperatureBcd");
await plc.WriteValueAsync(bcdKey, new Bcd16(235), CancellationToken.None);
Bcd16? displayed = await plc.ReadValueAsync(bcdKey, CancellationToken.None);
Console.WriteLine(displayed?.Value);

Registration, cache, observations, and direct commands

AddUpdateTagItem(PlcTag<T>) registers or updates the logical definition. RemoveTagItem(name) returns true only if a definition existed. GetValue(key) is cached and therefore never a substitute for a command read. Observe(key) emits changed values for one registered definition, while ObserveAll emits every changed IPlcTag. SetValue(key, value) starts a background write to preserve compatibility with reactive UIs; it has no completion result. Use WriteValueAsync for a command that requires acknowledgement, cancellation, or a catchable failure. ReadValueAsync directly reads and updates the cache. Keep Errors subscribed for polling/queued-write failures; error streams and subscriptions must be disposed independently of the facade.

using IoT.Driver.Core;
using IoT.Driver.OmronPlcRx.Tags;

var pump = new LogicalTagKey<bool>("PumpEnabled");
var batch = new LogicalTagKey<int>("BatchCount");
using var changes = plc.Observe(pump).Subscribe(value => Console.WriteLine($"pump={value}"));
using var all = plc.ObserveAll.Subscribe(tag => Console.WriteLine($"{tag?.TagName}={tag?.Value}"));
using var errors = plc.Errors.Subscribe(error => Console.Error.WriteLine(error?.Message));

plc.SetValue(pump, true); // queue-only: observe Errors for failure
using var deadline = new CancellationTokenSource(TimeSpan.FromSeconds(2));
try
{
    int? count = await plc.ReadValueAsync(batch, deadline.Token);
    await plc.WriteValueAsync(pump, count is not null, deadline.Token);
}
catch (OperationCanceledException) { Console.Error.WriteLine("PLC command timed out."); }
catch (OmronPLCException ex) { Console.Error.WriteLine(ex.Message); }

PLC clock and cycle-time commands

ReadClockAsync(token) returns ReadClockResult, whose clock value and operation metadata describe the reply. WriteClockAsync(DateTimeOffset, token) infers the day of week. WriteClockAsync(DateTimeOffset, int dayOfWeek, token) is the explicit overload; day of week must be 0–6. Both return WriteClockResult. ReadCycleTimeAsync(token) returns ReadCycleTimeResult with the controller's min/max/average cycle information. These calls operate directly on the controller and should be used sparingly during production; treat cancellation as an incomplete operation rather than proof it was not received.

using var commandDeadline = new CancellationTokenSource(TimeSpan.FromSeconds(5));
try
{
    var before = await plc.ReadClockAsync(commandDeadline.Token);
    Console.WriteLine($"PLC time: {before.Clock:O}");

    var clockWrite = await plc.WriteClockAsync(DateTimeOffset.UtcNow, commandDeadline.Token);
    var cycle = await plc.ReadCycleTimeAsync(commandDeadline.Token);
    Console.WriteLine($"cycle min={cycle.MinimumCycleTime}, max={cycle.MaximumCycleTime}");
}
catch (OperationCanceledException) { Console.Error.WriteLine("Clock/cycle request cancelled."); }
catch (FINSException ex) { Console.Error.WriteLine($"FINS rejected request: {ex.Message}"); }

Async enumeration and logical tags

OmronPlcRxAsyncObservableExtensions bridges Observe, ObserveAll, and Errors into IObservableAsync<T> through ObserveAsAsyncObservable, ObserveAllAsAsyncObservable, and ErrorsAsAsyncObservable; ObserveValuesAsync supplies asynchronous value enumeration. Each wrapper still owns/creates a subscription, so pass a cancellation token to consumers and dispose the client at application shutdown.

OmronLogicalTagClient is a higher-level catalog that creates/registers tags, reads/writes one or many logical values, exposes observable and async enumeration, and supports store/import/export/group CRUD where configured. It adds planning/batching and persistence convenience; it does not change the atomicity guarantees of the physical PLC. Use the core facade when a physical address/type must be explicit at the call site, and use logical tags when a reviewed catalog owns that mapping.

// A direct stream can be consumed as async enumeration with cancellation.
using var readWindow = new CancellationTokenSource(TimeSpan.FromSeconds(10));
await foreach (var value in plc.ObserveValuesAsync(new LogicalTagKey<int>("BatchCount"), readWindow.Token))
{
    Console.WriteLine($"batch={value}");
    if (value is > 1000) break;
}

When an application is already built on IObservableAsync<T>, convert individual values, all-tag changes, or driver errors with OmronPlcRxAsyncObservableExtensions. Convert back with ObservableAsyncBridgeExtensions.ToObservable only at the boundary where a classic IObservable<T> subscriber is required. The async stream does not turn a queued SetValue into an acknowledged command; use WriteValueAsync for that.

using IoT.Driver.Core;
using IoT.Driver.OmronPlcRx.Async;
using IoT.Driver.Serial;

var levelKey = new LogicalTagKey<float>("TankLevel");
var asyncLevels = plc.ObserveAsAsyncObservable(levelKey);
using var levels = ObservableAsyncBridgeExtensions.ToObservable(asyncLevels)
    .Subscribe(level => Console.WriteLine($"tank level={level}"));
using var errors = ObservableAsyncBridgeExtensions.ToObservable(plc.ErrorsAsAsyncObservable())
    .Subscribe(error => Console.Error.WriteLine(error?.Message));

Use ObserveValuesAsync when a sequential consumer is clearer than a callback. Cancellation ends the enumerable and the client still owns the polling/connection lifetime.

using var stop = new CancellationTokenSource(TimeSpan.FromSeconds(30));
await foreach (float? level in plc.ObserveValuesAsync(levelKey, stop.Token))
{
    if (level is > 90f)
        Console.WriteLine("High-level alarm policy should run here.");
}

Host Link and Toolbus codec testing

HostLinkFinsFrameCodec and ToolbusFinsFrameCodec are framing utilities for serial adapters and protocol tests. Normal application traffic should use OmronPlcRx with OmronSerialOptions; do not send codec output through an arbitrary serial port without the expected serial protocol. Host Link validates FCS/unit/header/end-code on decode; Toolbus validates start byte, declared length, checksum, and the FINS response header.

using IoT.Driver.OmronPlcRx;

var hostLinkOptions = new OmronSerialOptions("COM3")
{
    FrameMode = OmronHostLinkFinsFrameMode.Network,
};
var hostLink = new HostLinkFinsFrameCodec(hostLinkOptions);

// A FINS request always has a 10-byte header followed by a 2-byte command code.
ReadOnlyMemory<byte> finsRequest = new byte[12] { 0x80, 0, 2, 0, 0, 1, 0, 0, 11, 1, 1, 1 };
string hostLinkRequest = hostLink.EncodeRequest(finsRequest);
Memory<byte> toolbusRequest = ToolbusFinsFrameCodec.EncodeRequest(finsRequest);
Console.WriteLine(hostLinkRequest); // ends with FCS + "*\\r"
Console.WriteLine(ToolbusFinsFrameCodec.CalculateChecksum(toolbusRequest.Span[..^2]));

// Build minimal complete response frames for a codec unit test.
var finsResponse = new byte[14];
finsResponse[0] = 0xC0;
string hostLinkBody = "@00FA00" + BitConverter.ToString(finsResponse).Replace("-", string.Empty);
string hostLinkResponse = hostLinkBody + HostLinkFinsFrameCodec.CalculateFcs(hostLinkBody) + "*\r";
Memory<byte> finsReply = hostLink.DecodeResponse(hostLinkResponse);

var toolbusResponse = new byte[3 + finsResponse.Length + 2];
toolbusResponse[0] = 0xAB;
toolbusResponse[1] = 0;
toolbusResponse[2] = (byte)(finsResponse.Length + 2);
finsResponse.CopyTo(toolbusResponse, 3);
ushort checksum = ToolbusFinsFrameCodec.CalculateChecksum(toolbusResponse.AsSpan(0, toolbusResponse.Length - 2));
toolbusResponse[^2] = (byte)(checksum >> 8);
toolbusResponse[^1] = (byte)checksum;
Memory<byte> toolbusReply = ToolbusFinsFrameCodec.DecodeResponse(toolbusResponse);

Explicit packed-BCD conversion

Bcd16, BcdU16, Bcd32, and BcdU32 are strongly typed PLC tag values. BCDConverter is for an explicit boundary conversion when a command or capture supplies raw BCD bytes/words. The value 0x0235 represents decimal 235, not binary 565; reject malformed BCD instead of treating it as a normal integer.

using IoT.Driver.OmronPlcRx.Core.Converters;

short encoded = BCDConverter.GetBCDWord(235);
short decoded = BCDConverter.ToInt16(encoded);
if (decoded != 235) throw new InvalidOperationException("Unexpected packed BCD conversion.");

short[] encoded32 = BCDConverter.GetBCDWords(12_345_678);
int decoded32 = BCDConverter.ToInt32(encoded32[0], encoded32[1]);
Console.WriteLine(decoded32);

Logical-tag persistence, CRUD, and combined batch command

Construct OmronLogicalTagClient with a SQLite connection string when the reviewed tag map must persist. Initialize the store before CRUD, and remember that UpsertTagAsync also registers the tag with the PLC facade. ReadManyAsync / WriteManyAsync preserve caller order and use grouped FINS operations where the facade supports them; they are not a PLC transaction.

using IoT.Driver.Core;

var database = $"Data Source={Path.Combine(AppContext.BaseDirectory, "omron-tags.db")}";
using var tags = new OmronLogicalTagClient(plc, database);
await tags.InitializeStoreAsync(CancellationToken.None);

var process = new LogicalTagGroup("Process");
await tags.UpsertGroupAsync(process, CancellationToken.None);
var temperature = tags.CreateTag(new PlcTag<short>("Temperature", "D200"),
    groupName: "Process", description: "Product temperature", metadata: null,
    accessMode: LogicalTagAccessMode.ReadWrite, scanInterval: TimeSpan.FromMilliseconds(250));
await tags.UpsertTagAsync(temperature, CancellationToken.None);

using var import = new StringReader(
    "Name,Address,DataType,GroupName,Description,Metadata,AccessMode,ScanIntervalMilliseconds\n" +
    "HighTemperature,D201,Int16,Process,High limit,,ReadWrite,250\n");
IReadOnlyList<LogicalTag> imported = await tags.ImportCsvAsync(import, ',', CancellationToken.None);
using var export = new StringWriter();
await tags.ExportCsvAsync(export, ',', CancellationToken.None);
Console.WriteLine($"Imported {imported.Count} tags; CSV length = {export.GetStringBuilder().Length}.");

LogicalTag? stored = await tags.GetTagAsync("Temperature", CancellationToken.None);
if (stored is not null)
{
    var options = stored.CurrentOptions();
    options.Description = "Validated process temperature";
    await tags.EditTagAsync(stored.WithOptions(options), CancellationToken.None);
}

var results = await tags.WriteManyAsync(
    [new LogicalTagValue("Temperature", (short)185, TimeProvider.System.GetUtcNow())],
    CancellationToken.None);
if (!results.All(static result => result.Succeeded))
    throw new InvalidOperationException("Logical write failed.");

await tags.DeleteTagAsync("Temperature", CancellationToken.None);
await tags.DeleteTagAsync("HighTemperature", CancellationToken.None);
await tags.DeleteGroupAsync("Process", CancellationToken.None);

Deterministic simulator workflow

OmronPlcSimulator implements IOmronPlcRx so application code can be exercised without a network endpoint. Register the same PlcTag<T>, seed a value, optionally queue a fault, then read/write/observe through the normal interface. Operations returns OmronSimulatorOperationRecord entries, while OmronSimulatorOperation describes the recorded kind. Use this for timeout/error/UI tests; it is not a protocol emulator or safety certification.

using var simulator = new OmronPlcSimulator();
await simulator.ConnectAsync(CancellationToken.None); // useful after construction with initiallyConnected: false
var simulatedPump = new PlcTag<bool>("PumpEnabled", "D100.0");
simulator.AddUpdateTagItem(simulatedPump);
simulator.Seed(simulatedPump, false);
using var observed = simulator.Observe(new LogicalTagKey<bool>("PumpEnabled"))
    .Subscribe(Console.WriteLine);
await simulator.WriteValueAsync(new LogicalTagKey<bool>("PumpEnabled"), true, CancellationToken.None);
Console.WriteLine(simulator.Operations.Count);
simulator.Disconnect(); // retains registrations and seeded memory

Faults can deliberately disconnect the simulator. Handle the expected exception, call ReconnectAsync, and then repeat an awaited command; ReconnectCount and Operations make this recovery path assertable in application tests.

using IoT.Driver.Core;
using IoT.Driver.OmronPlcRx.Tags;

using var simulator = new OmronPlcSimulator(initiallyConnected: true);
var speed = new PlcTag<short>("Speed", "D100");
simulator.AddUpdateTagItem(speed);
simulator.Seed(speed, (short)25);
var speedKey = new LogicalTagKey<short>("Speed");
simulator.QueueFault(OmronSimulatorOperation.Read, new TimeoutException("Simulated cable loss"));
try
{
    await simulator.ReadValueAsync(speedKey, CancellationToken.None);
}
catch (OmronPLCException)
{
    await simulator.ReconnectAsync(CancellationToken.None);
}
short? recovered = await simulator.ReadValueAsync(speedKey, CancellationToken.None);
Console.WriteLine($"value={recovered}, reconnects={simulator.ReconnectCount}");

Combined workflow 1: network polling with explicit command verification

This keeps telemetry reactive, executes a command with an acknowledgement, and records failures without allowing a change stream to issue writes.

var motor = new LogicalTagKey<bool>("PumpEnabled");
var level = new LogicalTagKey<float>("TankLevel");
using var telemetry = plc.Observe(level).Subscribe(v => Console.WriteLine($"level={v}"));
using var faults = plc.Errors.Subscribe(e => Console.Error.WriteLine(e?.Message));
using var commandCt = new CancellationTokenSource(TimeSpan.FromSeconds(3));

float? currentLevel = await plc.ReadValueAsync(level, commandCt.Token);
if (currentLevel is < 85f)
    await plc.WriteValueAsync(motor, true, commandCt.Token);

Combined workflow 2: serial commissioning with clock check and BCD recipe

var recipe = new LogicalTagKey<Bcd16>("TemperatureBcd");
using var faults = serialPlc.Errors.Subscribe(e => Console.Error.WriteLine(e?.Message));
using var commissioning = new CancellationTokenSource(TimeSpan.FromSeconds(5));

var cycle = await serialPlc.ReadCycleTimeAsync(commissioning.Token);
if (cycle.MaximumCycleTime > 1_000d) // cycle-time values are milliseconds
    throw new InvalidOperationException("Controller cycle time is outside commissioning limit.");

await serialPlc.WriteValueAsync(recipe, new Bcd16(180), commissioning.Token);
var verify = await serialPlc.ReadValueAsync(recipe, commissioning.Token);
if (verify?.Value != 180) throw new InvalidOperationException("Recipe verification failed.");

Complete generator workflow

Install IoT-Driver.OmronPlcRx.Generators explicitly when a project needs source-generated bindings. Runtime packages never carry the generator assembly. Decorate a partial model with binding metadata and fields annotated by PlcTagAttribute. TagName selects the logical name; Register controls registration, Observe controls generated observation, and Writable requests write helpers. For each tag it generates the current value property, <Property>Observable, and—on .NET 8+—<Property>ObservableAsync; it also generates Read<Property>Async, Write<Property>, and Write<Property>Async for writable tags. Dispose the binding returned by BindPlcTags.

using IoT.Driver.OmronPlcRx;

[PlcTagBinding]
public partial class MixerTags
{
    [PlcTag("D100.0", TagName = "MixerRun", Writable = true)]
    private bool _mixerRun;

    [PlcTag("D200", TagName = "MixerSpeed", Observe = true)]
    private short _mixerSpeed;
}

var model = new MixerTags();
model.RegisterPlcTags(plc);
using var binding = model.BindPlcTags(plc);
model.WriteMixerRun(plc, true);
var written = await model.WriteMixerRunAsync(true, CancellationToken.None);
if (!written.Succeeded) throw new InvalidOperationException(written.Error);
using var speed = model.MixerSpeedObservable.Subscribe(Console.WriteLine);
#if NET8_0_OR_GREATER
using var asyncSpeed = ObservableAsyncBridgeExtensions.ToObservable(model.MixerSpeedObservableAsync)
    .Subscribe(Console.WriteLine);
#endif

Complete public API reference

The reactive package has the same inventory under IoT.Driver.OmronPlcRx.Reactive.

Area	Public types and primary members
Root	`IOmronPlcRx` and `OmronPlcRx`: `ObserveAll`, `Errors`, controller metadata, `AddUpdateTagItem`, `RemoveTagItem`, `Observe`, `GetValue`, `SetValue`, `ReadValueAsync`, `WriteValueAsync`, clock/cycle methods, and `Dispose`. `OmronConnectionOptions`, `OmronSerialOptions`, `OmronPlcSimulator`, `OmronSimulatorOperation`, `OmronSimulatorOperationRecord`, `OmronHostLinkFinsFrameMode`, and `OmronSerialProtocol`.
Tags	`IPlcTag` and `PlcTag<T>` (`TagName`, `Address`, `Value`, `TagType`).
Results	`ReadBitsResult`, `ReadWordsResult`, `ReadClockResult`, `ReadCycleTimeResult`, `WriteBitsResult`, `WriteWordsResult`, and `WriteClockResult`.
Enums and exceptions	`ConnectionMethod`, `MemoryBitDataType`, `MemoryWordDataType`, `PlcType`, `FINSException`, and `OmronPLCException`.
Core	`Bcd16`, `BcdU16`, `Bcd32`, `BcdU32`, `BCDConverter`, `HostLinkFinsFrameCodec`, and `ToolbusFinsFrameCodec`.
Logical tags	`OmronLogicalTagClient`; use it for catalog-backed, batch logical-tag work. Its public catalog and persistence operations are documented below.
Async and generation	`OmronPlcRxAsyncObservableExtensions`, `PlcTagAttribute`, `PlcTagBindingAttribute`, and the `OmronPlcRx.SourceGenerators.PlcTagSourceGenerator` analyzer.

Member-by-member contract

Member family	Inputs and return	Failure, lifecycle, and use
Construction/options	Network options or serial parameters; optional polling interval.	Validate serial settings first, use one client per endpoint, and dispose it after subscriptions.
Tags/keys	`PlcTag<T>(tagName, address)`, `LogicalTagKey<T>(tagName)`, `AddUpdateTagItem`, `RemoveTagItem`.	The type/name must agree across all calls. Registration changes the polling set.
Cache/streams	`GetValue`, `Observe`, `ObserveAll`, `Errors`.	Cache is not a direct read. Dispose subscriptions; errors from poll/background writes appear on `Errors`.
Commands	`SetValue`, `ReadValueAsync`, `WriteValueAsync`.	`SetValue` is fire-and-forget. Await explicit methods with a cancellation token and catch FINS/Omron errors.
Clock/cycle	`ReadClockAsync`, both `WriteClockAsync` overloads, `ReadCycleTimeAsync`.	Direct PLC commands return result records; day is inferred or must be 0–6.
Options/protocol	`OmronConnectionOptions`, `OmronSerialOptions`, protocol/frame enums and codecs.	Select transport/framing to match the PLC; only FINS Host Link/Toolbus are exposed.
Simulation/logical/generation	`OmronPlcSimulator`, operation records, `OmronLogicalTagClient`, async extensions, BCD values/codecs, generator attributes.	Simulator and catalog make tests/configuration repeatable; they do not create PLC transaction semantics.

Supporting public member index

Feature	Members and use
Logical catalog and persistence	`CreateTag`, `RegisterTag`, `RemoveTag`, `ReadAsync`, `ReadManyAsync`, `WriteAsync`, `WriteManyAsync`, `ObserveAsync`, `ObserveMany`, `ObserveManyAsync`, `InitializeStoreAsync`, `LoadTagsAsync`, `GetTagAsync`, `ListTagsAsync`, `EditTagAsync`, `DeleteTagAsync`, `UpsertTagAsync`, `GetGroupAsync`, `ListGroupsAsync`, `UpsertGroupAsync`, `DeleteGroupAsync`, `ImportCsvAsync`, `ExportCsvAsync`. These are cancellation-aware catalog operations; check result success/error and remember that batch planning is not a PLC transaction.
Simulator lifecycle and faults	`ConnectAsync`, `Disconnect`, `ReconnectAsync`, `QueueFault`, `Seed`, and operation records. A simulator fault may disconnect the simulated link; reconnect explicitly before the next command.
FINS serial framing	`OpenAsync`, `Close`, `DiscardInBuffer`, `EncodeRequest`, `DecodeResponse`, `CalculateChecksum`, and `CalculateFcs`. Use the serial options/connection facade for normal traffic; these codec/frame methods are for adapter/protocol tests and require exact framing.
BCD conversion	`GetBCDByte`, `GetBCDBytes`, `GetBCDWord`, `GetBCDWords`, `ToByte`, `ToInt16`, `ToUInt16`, `ToInt32`, and `ToUInt32`. They translate packed BCD, not normal binary; invalid BCD digits or an unsuitable width are caller errors.
Value semantics	`Equals`, `GetHashCode`, `ToString`, and `Index` are value/compatibility members on records/wrappers. Use typed tags/results for PLC work rather than comparing formatted text.

Operational guidance

Use one long-lived driver per endpoint; register all tags before relying on polling; keep subscriptions and the driver disposed with the application lifetime. Select a poll interval that the PLC, network, and number of tags can sustain. Keep command writes out of a high-frequency value stream, and monitor Errors plus controller metadata during commissioning. Do not expose the PLC network directly to untrusted networks.

Troubleshooting

Symptom	Check
No values arrive	Confirm FINS node IDs, transport/port, host, address syntax, tag registration, and subscription lifetime.
`KeyNotFoundException` or default value	Use the same tag name and generic type in registration and logical key.
Serial connection fails	Call `Validate()`, then verify protocol, framing, COM port, baud/parity/data/stop bits, and Host Link unit/wait values.
Write did not take effect	Use `WriteValueAsync` to observe the operation; inspect `Errors`; verify PLC permissions and program interlocks.
Generator diagnostics	Make the target type `partial`, use a supported field type/address, and remove generated-name collisions.

AI skill

For implementation guidance, load skills/omron-plc-rx/SKILL.md. It directs an agent to this README for the detailed source-grounded reference.

Exhaustive public API reference

This catalogue is generated from the packaged runtime assemblies and their XML documentation. It includes exported public types and their declared public members; inherited members and non-public implementation details are intentionally omitted.

`OmronPlcRx`

Exported public types: 35; declared public members: 352.

`T:IoT.Driver.OmronPlcRx.Async.OmronPlcRxAsyncObservableExtensions`

public class IoT.Driver.OmronPlcRx.Async.OmronPlcRxAsyncObservableExtensions

Bridges Omron PLC classic Rx streams into ReactiveUI.Primitives.Async observables.

Declared public members

`M:IoT.Driver.OmronPlcRx.Async.OmronPlcRxAsyncObservableExtensions.ErrorsAsAsyncObservable(IoT.Driver.OmronPlcRx.IOmronPlcRx)`

public static ReactiveUI.Primitives.Async.IObservableAsync<IoT.Driver.OmronPlcRx.OmronPLCException> ErrorsAsAsyncObservable(IoT.Driver.OmronPlcRx.IOmronPlcRx plc)

Observes PLC operational errors as an async observable.

Parameter plc: The PLC reactive facade.
Returns: An async observable of PLC errors.

`M:IoT.Driver.OmronPlcRx.Async.OmronPlcRxAsyncObservableExtensions.ObserveAllAsAsyncObservable(IoT.Driver.OmronPlcRx.IOmronPlcRx)`

public static ReactiveUI.Primitives.Async.IObservableAsync<IoT.Driver.OmronPlcRx.Tags.IPlcTag> ObserveAllAsAsyncObservable(IoT.Driver.OmronPlcRx.IOmronPlcRx plc)

Observes every changed PLC tag as an async observable.

Parameter plc: The PLC reactive facade.
Returns: An async observable of all changed tags.

M:IoT.Driver.OmronPlcRx.Async.OmronPlcRxAsyncObservableExtensions.ObserveAsAsyncObservable``1(IoT.Driver.OmronPlcRx.IOmronPlcRx,IoT.Driver.Core.LogicalTagKey1{``0})`

public static ReactiveUI.Primitives.Async.IObservableAsync<T> ObserveAsAsyncObservable<T>(IoT.Driver.OmronPlcRx.IOmronPlcRx plc, IoT.Driver.Core.LogicalTagKey<T> tag)

Executes the ObserveAsAsyncObservable operation.

Parameter plc: The plc value.
Parameter tag: The tag value.
Returns: A ReactiveUI.Primitives.Async.IObservableAsync<T> result.

M:IoT.Driver.OmronPlcRx.Async.OmronPlcRxAsyncObservableExtensions.ObserveValuesAsync``1(IoT.Driver.OmronPlcRx.IOmronPlcRx,IoT.Driver.Core.LogicalTagKey1{``0},System.Threading.CancellationToken)`

public static System.Collections.Generic.IAsyncEnumerable<T> ObserveValuesAsync<T>(IoT.Driver.OmronPlcRx.IOmronPlcRx plc, IoT.Driver.Core.LogicalTagKey<T> tag, System.Threading.CancellationToken cancellationToken)

Executes the ObserveValuesAsync operation.

Parameter plc: The plc value.
Parameter tag: The tag value.
Parameter cancellationToken: The cancellationToken value.
Returns: A System.Collections.Generic.IAsyncEnumerable<T> result.

`T:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter`

public class IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter

Converts between BCD encoded values and numeric values.

Declared public members

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.GetBCDByte(System.Byte)`

public static byte GetBCDByte(byte binaryValue)

Gets the BCD byte.

Parameter binaryValue: The binary value.
Returns: A BCD-encoded byte.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.GetBCDBytes(System.Int16)`

public static byte[] GetBCDBytes(short binaryValue)

Gets the BCD bytes.

Parameter binaryValue: The binary value.
Returns: A BCD-encoded byte array.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.GetBCDBytes(System.Int32)`

public static byte[] GetBCDBytes(int binaryValue)

Gets the BCD bytes.

Parameter binaryValue: The binary value.
Returns: A BCD-encoded byte array.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.GetBCDBytes(System.UInt16)`

public static byte[] GetBCDBytes(ushort binaryValue)

Gets the BCD bytes.

Parameter binaryValue: The binary value.
Returns: A BCD-encoded byte array.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.GetBCDBytes(System.UInt32)`

public static byte[] GetBCDBytes(uint binaryValue)

Gets the BCD bytes.

Parameter binaryValue: The binary value.
Returns: A BCD-encoded byte array.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.GetBCDWord(System.Int16)`

public static short GetBCDWord(short binaryValue)

Gets the BCD word.

Parameter binaryValue: The binary value.
Returns: A BCD-encoded word.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.GetBCDWord(System.UInt16)`

public static short GetBCDWord(ushort binaryValue)

Gets the BCD word.

Parameter binaryValue: The binary value.
Returns: A BCD-encoded word.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.GetBCDWords(System.Int32)`

public static short[] GetBCDWords(int binaryValue)

Gets the BCD words.

Parameter binaryValue: The binary value.
Returns: An array of two BCD-encoded words.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.GetBCDWords(System.UInt32)`

public static short[] GetBCDWords(uint binaryValue)

Gets the BCD words.

Parameter binaryValue: The binary value.
Returns: An array of two BCD-encoded words.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.ToByte(System.Byte)`

public static byte ToByte(byte bcdByte)

Converts to byte.

Parameter bcdByte: The BCD byte.
Returns: A byte representing the converted value.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.ToInt16(System.Byte[])`

public static short ToInt16(byte[] bcdBytes)

Converts to int16.

Parameter bcdBytes: The BCD bytes.
Returns: A short.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.ToInt16(System.Int16)`

public static short ToInt16(short bcdWord)

Converts to int16.

Parameter bcdWord: The BCD word.
Returns: A short.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.ToInt32(System.Byte[])`

public static int ToInt32(byte[] bcdBytes)

Converts to int32.

Parameter bcdBytes: The BCD bytes.
Returns: An int.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.ToInt32(System.Int16,System.Int16)`

public static int ToInt32(short bcdWord1, short bcdWord2)

Converts to int32.

Parameter bcdWord1: The BCD word1.
Parameter bcdWord2: The BCD word2.
Returns: An int.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.ToUInt16(System.Byte[])`

public static ushort ToUInt16(byte[] bcdBytes)

Converts to uint16.

Parameter bcdBytes: The BCD bytes.
Returns: A ushort.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.ToUInt16(System.Int16)`

public static ushort ToUInt16(short bcdWord)

Converts to uint16.

Parameter bcdWord: The BCD word.
Returns: A ushort.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.ToUInt32(System.Byte[])`

public static uint ToUInt32(byte[] bcdBytes)

Converts to uint32.

Parameter bcdBytes: The BCD bytes.
Returns: A uint.

`M:IoT.Driver.OmronPlcRx.Core.Converters.BCDConverter.ToUInt32(System.Int16,System.Int16)`

public static uint ToUInt32(short bcdWord1, short bcdWord2)

Converts to uint32.

Parameter bcdWord1: The BCD word1.
Parameter bcdWord2: The BCD word2.
Returns: A uint.

`T:IoT.Driver.OmronPlcRx.Core.Types.Bcd16`

public struct IoT.Driver.OmronPlcRx.Core.Types.Bcd16

Signed 16-bit BCD numeric wrapper.

Declared public members

`M:IoT.Driver.OmronPlcRx.Core.Types.Bcd16.#ctor(System.Int16)`

public IoT.Driver.OmronPlcRx.Core.Types.Bcd16(short value)

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.Core.Types.Bcd16 struct.

Parameter value: The signed value.

`M:IoT.Driver.OmronPlcRx.Core.Types.Bcd16.Equals(IoT.Driver.OmronPlcRx.Core.Types.Bcd16)`

public bool Equals(IoT.Driver.OmronPlcRx.Core.Types.Bcd16 other)

Determines whether the supplied value is equal to the current value.

Parameter other: The other value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Core.Types.Bcd16.Equals(System.Object)`

public bool Equals(object obj)

Determines whether the supplied value is equal to the current value.

Parameter obj: The obj value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Core.Types.Bcd16.GetHashCode`

public int GetHashCode()

Inherits XML documentation from its implemented or overridden member.

Returns: A int result.

`M:IoT.Driver.OmronPlcRx.Core.Types.Bcd16.ToString`

public string ToString()

Inherits XML documentation from its implemented or overridden member.

Returns: A string result.

`M:IoT.Driver.OmronPlcRx.Core.Types.Bcd16.op_Equality(IoT.Driver.OmronPlcRx.Core.Types.Bcd16,IoT.Driver.OmronPlcRx.Core.Types.Bcd16)`

public static bool op_Equality(IoT.Driver.OmronPlcRx.Core.Types.Bcd16 left, IoT.Driver.OmronPlcRx.Core.Types.Bcd16 right)

Determines whether the two supplied values are equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Core.Types.Bcd16.op_Inequality(IoT.Driver.OmronPlcRx.Core.Types.Bcd16,IoT.Driver.OmronPlcRx.Core.Types.Bcd16)`

public static bool op_Inequality(IoT.Driver.OmronPlcRx.Core.Types.Bcd16 left, IoT.Driver.OmronPlcRx.Core.Types.Bcd16 right)

Determines whether the two supplied values are not equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`P:IoT.Driver.OmronPlcRx.Core.Types.Bcd16.Value`

public short Value { get; }

Gets the numeric value.

Value: The Value value.

`T:IoT.Driver.OmronPlcRx.Core.Types.Bcd32`

public struct IoT.Driver.OmronPlcRx.Core.Types.Bcd32

Signed 32-bit BCD numeric wrapper.

Declared public members

`M:IoT.Driver.OmronPlcRx.Core.Types.Bcd32.#ctor(System.Int32)`

public IoT.Driver.OmronPlcRx.Core.Types.Bcd32(int value)

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.Core.Types.Bcd32 struct.

Parameter value: The signed value.

`M:IoT.Driver.OmronPlcRx.Core.Types.Bcd32.Equals(IoT.Driver.OmronPlcRx.Core.Types.Bcd32)`

public bool Equals(IoT.Driver.OmronPlcRx.Core.Types.Bcd32 other)

Determines whether the supplied value is equal to the current value.

Parameter other: The other value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Core.Types.Bcd32.Equals(System.Object)`

public bool Equals(object obj)

Determines whether the supplied value is equal to the current value.

Parameter obj: The obj value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Core.Types.Bcd32.GetHashCode`

public int GetHashCode()

Inherits XML documentation from its implemented or overridden member.

Returns: A int result.

`M:IoT.Driver.OmronPlcRx.Core.Types.Bcd32.ToString`

public string ToString()

Inherits XML documentation from its implemented or overridden member.

Returns: A string result.

`M:IoT.Driver.OmronPlcRx.Core.Types.Bcd32.op_Equality(IoT.Driver.OmronPlcRx.Core.Types.Bcd32,IoT.Driver.OmronPlcRx.Core.Types.Bcd32)`

public static bool op_Equality(IoT.Driver.OmronPlcRx.Core.Types.Bcd32 left, IoT.Driver.OmronPlcRx.Core.Types.Bcd32 right)

Determines whether the two supplied values are equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Core.Types.Bcd32.op_Inequality(IoT.Driver.OmronPlcRx.Core.Types.Bcd32,IoT.Driver.OmronPlcRx.Core.Types.Bcd32)`

public static bool op_Inequality(IoT.Driver.OmronPlcRx.Core.Types.Bcd32 left, IoT.Driver.OmronPlcRx.Core.Types.Bcd32 right)

Determines whether the two supplied values are not equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`P:IoT.Driver.OmronPlcRx.Core.Types.Bcd32.Value`

public int Value { get; }

Gets the numeric value.

Value: The Value value.

`T:IoT.Driver.OmronPlcRx.Core.Types.BcdU16`

public struct IoT.Driver.OmronPlcRx.Core.Types.BcdU16

Unsigned 16-bit BCD numeric wrapper.

Declared public members

`M:IoT.Driver.OmronPlcRx.Core.Types.BcdU16.#ctor(System.UInt16)`

public IoT.Driver.OmronPlcRx.Core.Types.BcdU16(ushort value)

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.Core.Types.BcdU16 struct.

Parameter value: The unsigned value.

`M:IoT.Driver.OmronPlcRx.Core.Types.BcdU16.Equals(IoT.Driver.OmronPlcRx.Core.Types.BcdU16)`

public bool Equals(IoT.Driver.OmronPlcRx.Core.Types.BcdU16 other)

Determines whether the supplied value is equal to the current value.

Parameter other: The other value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Core.Types.BcdU16.Equals(System.Object)`

public bool Equals(object obj)

Determines whether the supplied value is equal to the current value.

Parameter obj: The obj value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Core.Types.BcdU16.GetHashCode`

public int GetHashCode()

Inherits XML documentation from its implemented or overridden member.

Returns: A int result.

`M:IoT.Driver.OmronPlcRx.Core.Types.BcdU16.ToString`

public string ToString()

Inherits XML documentation from its implemented or overridden member.

Returns: A string result.

`M:IoT.Driver.OmronPlcRx.Core.Types.BcdU16.op_Equality(IoT.Driver.OmronPlcRx.Core.Types.BcdU16,IoT.Driver.OmronPlcRx.Core.Types.BcdU16)`

public static bool op_Equality(IoT.Driver.OmronPlcRx.Core.Types.BcdU16 left, IoT.Driver.OmronPlcRx.Core.Types.BcdU16 right)

Determines whether the two supplied values are equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Core.Types.BcdU16.op_Inequality(IoT.Driver.OmronPlcRx.Core.Types.BcdU16,IoT.Driver.OmronPlcRx.Core.Types.BcdU16)`

public static bool op_Inequality(IoT.Driver.OmronPlcRx.Core.Types.BcdU16 left, IoT.Driver.OmronPlcRx.Core.Types.BcdU16 right)

Determines whether the two supplied values are not equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`P:IoT.Driver.OmronPlcRx.Core.Types.BcdU16.Value`

public ushort Value { get; }

Gets the numeric value.

Value: The Value value.

`T:IoT.Driver.OmronPlcRx.Core.Types.BcdU32`

public struct IoT.Driver.OmronPlcRx.Core.Types.BcdU32

Unsigned 32-bit BCD numeric wrapper.

Declared public members

`M:IoT.Driver.OmronPlcRx.Core.Types.BcdU32.#ctor(System.UInt32)`

public IoT.Driver.OmronPlcRx.Core.Types.BcdU32(uint value)

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.Core.Types.BcdU32 struct.

Parameter value: The unsigned value.

`M:IoT.Driver.OmronPlcRx.Core.Types.BcdU32.Equals(IoT.Driver.OmronPlcRx.Core.Types.BcdU32)`

public bool Equals(IoT.Driver.OmronPlcRx.Core.Types.BcdU32 other)

Determines whether the supplied value is equal to the current value.

Parameter other: The other value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Core.Types.BcdU32.Equals(System.Object)`

public bool Equals(object obj)

Determines whether the supplied value is equal to the current value.

Parameter obj: The obj value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Core.Types.BcdU32.GetHashCode`

public int GetHashCode()

Inherits XML documentation from its implemented or overridden member.

Returns: A int result.

`M:IoT.Driver.OmronPlcRx.Core.Types.BcdU32.ToString`

public string ToString()

Inherits XML documentation from its implemented or overridden member.

Returns: A string result.

`M:IoT.Driver.OmronPlcRx.Core.Types.BcdU32.op_Equality(IoT.Driver.OmronPlcRx.Core.Types.BcdU32,IoT.Driver.OmronPlcRx.Core.Types.BcdU32)`

public static bool op_Equality(IoT.Driver.OmronPlcRx.Core.Types.BcdU32 left, IoT.Driver.OmronPlcRx.Core.Types.BcdU32 right)

Determines whether the two supplied values are equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Core.Types.BcdU32.op_Inequality(IoT.Driver.OmronPlcRx.Core.Types.BcdU32,IoT.Driver.OmronPlcRx.Core.Types.BcdU32)`

public static bool op_Inequality(IoT.Driver.OmronPlcRx.Core.Types.BcdU32 left, IoT.Driver.OmronPlcRx.Core.Types.BcdU32 right)

Determines whether the two supplied values are not equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`P:IoT.Driver.OmronPlcRx.Core.Types.BcdU32.Value`

public uint Value { get; }

Gets the numeric value.

Value: The Value value.

`T:IoT.Driver.OmronPlcRx.Enums.ConnectionMethod`

public enum IoT.Driver.OmronPlcRx.Enums.ConnectionMethod

Transport protocol used for communication with the PLC.

Declared public members

`F:IoT.Driver.OmronPlcRx.Enums.ConnectionMethod.Serial`

public static const IoT.Driver.OmronPlcRx.Enums.ConnectionMethod Serial

Serial FINS protocol using Host Link FINS or Toolbus framing.

`F:IoT.Driver.OmronPlcRx.Enums.ConnectionMethod.TCP`

public static const IoT.Driver.OmronPlcRx.Enums.ConnectionMethod TCP

Transmission Control Protocol.

`F:IoT.Driver.OmronPlcRx.Enums.ConnectionMethod.UDP`

public static const IoT.Driver.OmronPlcRx.Enums.ConnectionMethod UDP

User Datagram Protocol.

`T:IoT.Driver.OmronPlcRx.Enums.MemoryBitDataType`

public enum IoT.Driver.OmronPlcRx.Enums.MemoryBitDataType

Bit-addressable PLC memory areas.

Declared public members

`F:IoT.Driver.OmronPlcRx.Enums.MemoryBitDataType.Auxiliary`

public static const IoT.Driver.OmronPlcRx.Enums.MemoryBitDataType Auxiliary

Auxiliary area (A).

`F:IoT.Driver.OmronPlcRx.Enums.MemoryBitDataType.CommonIO`

public static const IoT.Driver.OmronPlcRx.Enums.MemoryBitDataType CommonIO

Common I/O area (CIO).

`F:IoT.Driver.OmronPlcRx.Enums.MemoryBitDataType.DataMemory`

public static const IoT.Driver.OmronPlcRx.Enums.MemoryBitDataType DataMemory

Data memory area (DM).

`F:IoT.Driver.OmronPlcRx.Enums.MemoryBitDataType.Holding`

public static const IoT.Driver.OmronPlcRx.Enums.MemoryBitDataType Holding

Holding area (H).

`F:IoT.Driver.OmronPlcRx.Enums.MemoryBitDataType.None`

public static const IoT.Driver.OmronPlcRx.Enums.MemoryBitDataType None

No bit-addressable memory area.

`F:IoT.Driver.OmronPlcRx.Enums.MemoryBitDataType.Work`

public static const IoT.Driver.OmronPlcRx.Enums.MemoryBitDataType Work

Work area (W).

`T:IoT.Driver.OmronPlcRx.Enums.MemoryWordDataType`

public enum IoT.Driver.OmronPlcRx.Enums.MemoryWordDataType

Word-addressable PLC memory areas.

Declared public members

`F:IoT.Driver.OmronPlcRx.Enums.MemoryWordDataType.Auxiliary`

public static const IoT.Driver.OmronPlcRx.Enums.MemoryWordDataType Auxiliary

Auxiliary area (A).

`F:IoT.Driver.OmronPlcRx.Enums.MemoryWordDataType.CommonIO`

public static const IoT.Driver.OmronPlcRx.Enums.MemoryWordDataType CommonIO

Common I/O area (CIO).

`F:IoT.Driver.OmronPlcRx.Enums.MemoryWordDataType.DataMemory`

public static const IoT.Driver.OmronPlcRx.Enums.MemoryWordDataType DataMemory

Data memory area (DM).

`F:IoT.Driver.OmronPlcRx.Enums.MemoryWordDataType.Holding`

public static const IoT.Driver.OmronPlcRx.Enums.MemoryWordDataType Holding

Holding area (H).

`F:IoT.Driver.OmronPlcRx.Enums.MemoryWordDataType.None`

public static const IoT.Driver.OmronPlcRx.Enums.MemoryWordDataType None

No word-addressable memory area.

`F:IoT.Driver.OmronPlcRx.Enums.MemoryWordDataType.Work`

public static const IoT.Driver.OmronPlcRx.Enums.MemoryWordDataType Work

Work area (W).

`T:IoT.Driver.OmronPlcRx.Enums.PlcType`

public enum IoT.Driver.OmronPlcRx.Enums.PlcType

Supported Omron PLC types used to adjust message capabilities and limits.

Declared public members

`F:IoT.Driver.OmronPlcRx.Enums.PlcType.CJ2`

public static const IoT.Driver.OmronPlcRx.Enums.PlcType CJ2

Omron CJ2 series.

`F:IoT.Driver.OmronPlcRx.Enums.PlcType.CP1`

public static const IoT.Driver.OmronPlcRx.Enums.PlcType CP1

Omron CP1 series.

`F:IoT.Driver.OmronPlcRx.Enums.PlcType.C_Series`

public static const IoT.Driver.OmronPlcRx.Enums.PlcType C_Series

Omron C-series (legacy).

`F:IoT.Driver.OmronPlcRx.Enums.PlcType.NJ101`

public static const IoT.Driver.OmronPlcRx.Enums.PlcType NJ101

Omron NJ101 series.

`F:IoT.Driver.OmronPlcRx.Enums.PlcType.NJ301`

public static const IoT.Driver.OmronPlcRx.Enums.PlcType NJ301

Omron NJ301 series.

`F:IoT.Driver.OmronPlcRx.Enums.PlcType.NJ501`

public static const IoT.Driver.OmronPlcRx.Enums.PlcType NJ501

Omron NJ501 series.

`F:IoT.Driver.OmronPlcRx.Enums.PlcType.NJ_NX_NY_Series`

public static const IoT.Driver.OmronPlcRx.Enums.PlcType NJ_NX_NY_Series

Generic NJ/NX/NY series.

`F:IoT.Driver.OmronPlcRx.Enums.PlcType.NX102`

public static const IoT.Driver.OmronPlcRx.Enums.PlcType NX102

Omron NX102 series.

`F:IoT.Driver.OmronPlcRx.Enums.PlcType.NX1P2`

public static const IoT.Driver.OmronPlcRx.Enums.PlcType NX1P2

Omron NX1P2 series.

`F:IoT.Driver.OmronPlcRx.Enums.PlcType.NX701`

public static const IoT.Driver.OmronPlcRx.Enums.PlcType NX701

Omron NX701 series.

`F:IoT.Driver.OmronPlcRx.Enums.PlcType.NY512`

public static const IoT.Driver.OmronPlcRx.Enums.PlcType NY512

Omron NY512 series.

`F:IoT.Driver.OmronPlcRx.Enums.PlcType.NY532`

public static const IoT.Driver.OmronPlcRx.Enums.PlcType NY532

Omron NY532 series.

`F:IoT.Driver.OmronPlcRx.Enums.PlcType.Unknown`

public static const IoT.Driver.OmronPlcRx.Enums.PlcType Unknown

Unknown or not yet identified.

`T:IoT.Driver.OmronPlcRx.FINSException`

public class IoT.Driver.OmronPlcRx.FINSException

An exception that represents a FINS protocol error or invalid response.

Declared public members

`M:IoT.Driver.OmronPlcRx.FINSException.#ctor`

public IoT.Driver.OmronPlcRx.FINSException()

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.FINSException class.

`M:IoT.Driver.OmronPlcRx.FINSException.#ctor(System.String)`

public IoT.Driver.OmronPlcRx.FINSException(string message)

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.FINSException class with a message.

Parameter message: The message that describes the error.

`M:IoT.Driver.OmronPlcRx.FINSException.#ctor(System.String,System.Exception)`

public IoT.Driver.OmronPlcRx.FINSException(string message, System.Exception innerException)

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.FINSException class.

Parameter message: The error message that explains the reason for the exception.
Parameter innerException: The exception that caused the current exception.

`T:IoT.Driver.OmronPlcRx.HostLinkFinsFrameCodec`

public class IoT.Driver.OmronPlcRx.HostLinkFinsFrameCodec

Encodes and decodes Omron FINS frames carried in Host Link serial frames.

Declared public members

`M:IoT.Driver.OmronPlcRx.HostLinkFinsFrameCodec.#ctor(IoT.Driver.OmronPlcRx.OmronSerialOptions)`

public IoT.Driver.OmronPlcRx.HostLinkFinsFrameCodec(IoT.Driver.OmronPlcRx.OmronSerialOptions options)

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.HostLinkFinsFrameCodec class.

Parameter options: Serial Host Link options.

`M:IoT.Driver.OmronPlcRx.HostLinkFinsFrameCodec.CalculateFcs(System.String)`

public static string CalculateFcs(string frameText)

Calculates the Host Link frame-check sequence.

Parameter frameText: Frame text from @ through the final text character, excluding FCS and terminator.
Returns: Two-character uppercase hexadecimal FCS.

`M:IoT.Driver.OmronPlcRx.HostLinkFinsFrameCodec.DecodeResponse(System.String)`

public System.Memory<byte> DecodeResponse(string frame)

Decodes an ASCII Host Link FINS response into a binary FINS response message.

Parameter frame: ASCII Host Link FINS response frame including FCS and terminator.
Returns: Binary FINS response message.

`M:IoT.Driver.OmronPlcRx.HostLinkFinsFrameCodec.EncodeRequest(System.ReadOnlyMemory`1{System.Byte})`

public string EncodeRequest(System.ReadOnlyMemory<byte> finsMessage)

Executes the EncodeRequest operation.

Parameter finsMessage: The finsMessage value.
Returns: A string result.

`T:IoT.Driver.OmronPlcRx.IOmronPlcRx`

public interface IoT.Driver.OmronPlcRx.IOmronPlcRx

Defines high-level Omron PLC operations and tag access.

Declared public members

M:IoT.Driver.OmronPlcRx.IOmronPlcRx.AddUpdateTagItem``1(IoT.Driver.OmronPlcRx.Tags.PlcTag1{``0})`

public void AddUpdateTagItem<T>(IoT.Driver.OmronPlcRx.Tags.PlcTag<T> tag)

Executes the AddUpdateTagItem operation.

Parameter tag: The tag value.

M:IoT.Driver.OmronPlcRx.IOmronPlcRx.GetValue``1(IoT.Driver.Core.LogicalTagKey1{``0})`

public T GetValue<T>(IoT.Driver.Core.LogicalTagKey<T> tag)

Executes the GetValue operation.

Parameter tag: The tag value.
Returns: A T result.

M:IoT.Driver.OmronPlcRx.IOmronPlcRx.Observe``1(IoT.Driver.Core.LogicalTagKey1{``0})`

public System.IObservable<T> Observe<T>(IoT.Driver.Core.LogicalTagKey<T> tag)

Executes the Observe operation.

Parameter tag: The tag value.
Returns: A System.IObservable<T> result.

`M:IoT.Driver.OmronPlcRx.IOmronPlcRx.ReadClockAsync(System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<IoT.Driver.OmronPlcRx.Results.ReadClockResult> ReadClockAsync(System.Threading.CancellationToken cancellationToken)

Reads the PLC real-time clock.

Parameter cancellationToken: Cancellation token.
Returns: Clock read result.

`M:IoT.Driver.OmronPlcRx.IOmronPlcRx.ReadCycleTimeAsync(System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult> ReadCycleTimeAsync(System.Threading.CancellationToken cancellationToken)

Reads PLC scan cycle time statistics.

Parameter cancellationToken: Cancellation token.
Returns: Cycle time statistics.

M:IoT.Driver.OmronPlcRx.IOmronPlcRx.ReadValueAsync``1(IoT.Driver.Core.LogicalTagKey1{``0},System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<T> ReadValueAsync<T>(IoT.Driver.Core.LogicalTagKey<T> tag, System.Threading.CancellationToken cancellationToken)

Executes the ReadValueAsync operation.

Parameter tag: The tag value.
Parameter cancellationToken: The cancellationToken value.
Returns: A System.Threading.Tasks.Task<T> result.

`M:IoT.Driver.OmronPlcRx.IOmronPlcRx.RemoveTagItem(System.String)`

public bool RemoveTagItem(string tagName)

Removes a registered tag definition.

Parameter tagName: Logical tag name.
Returns: when a tag was removed.

M:IoT.Driver.OmronPlcRx.IOmronPlcRx.SetValue``1(IoT.Driver.Core.LogicalTagKey1{`0},`0)`

public void SetValue<T>(IoT.Driver.Core.LogicalTagKey<T> tag, T value)

Executes the SetValue operation.

Parameter tag: The tag value.
Parameter value: The value value.

`M:IoT.Driver.OmronPlcRx.IOmronPlcRx.WriteClockAsync(System.DateTimeOffset,System.Int32,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<IoT.Driver.OmronPlcRx.Results.WriteClockResult> WriteClockAsync(System.DateTimeOffset newDateTime, int newDayOfWeek, System.Threading.CancellationToken cancellationToken)

Writes the PLC real-time clock with explicit day-of-week.

Parameter newDateTime: New date/time.
Parameter newDayOfWeek: Day of week (0-6).
Parameter cancellationToken: Cancellation token.
Returns: Clock write result.

`M:IoT.Driver.OmronPlcRx.IOmronPlcRx.WriteClockAsync(System.DateTimeOffset,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<IoT.Driver.OmronPlcRx.Results.WriteClockResult> WriteClockAsync(System.DateTimeOffset newDateTime, System.Threading.CancellationToken cancellationToken)

Writes the PLC real-time clock (day-of-week inferred from date).

Parameter newDateTime: New date/time.
Parameter cancellationToken: Cancellation token.
Returns: Clock write result.

M:IoT.Driver.OmronPlcRx.IOmronPlcRx.WriteValueAsync``1(IoT.Driver.Core.LogicalTagKey1{`0},`0,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task WriteValueAsync<T>(IoT.Driver.Core.LogicalTagKey<T> tag, T value, System.Threading.CancellationToken cancellationToken)

Executes the WriteValueAsync operation.

Parameter tag: The tag value.
Parameter value: The value value.
Parameter cancellationToken: The cancellationToken value.
Returns: A System.Threading.Tasks.Task result.

`P:IoT.Driver.OmronPlcRx.IOmronPlcRx.ControllerModel`

public string ControllerModel { get; }

Gets the PLC controller model string.

Value: The ControllerModel value.

`P:IoT.Driver.OmronPlcRx.IOmronPlcRx.ControllerVersion`

public string ControllerVersion { get; }

Gets the PLC controller version string.

Value: The ControllerVersion value.

`P:IoT.Driver.OmronPlcRx.IOmronPlcRx.Errors`

public System.IObservable<IoT.Driver.OmronPlcRx.OmronPLCException> Errors { get; }

Gets an observable of operational errors.

Value: The Errors value.

`P:IoT.Driver.OmronPlcRx.IOmronPlcRx.ObserveAll`

public System.IObservable<IoT.Driver.OmronPlcRx.Tags.IPlcTag> ObserveAll { get; }

Gets an observable of all tag change events.

Value: The ObserveAll value.

`P:IoT.Driver.OmronPlcRx.IOmronPlcRx.PlcType`

public IoT.Driver.OmronPlcRx.Enums.PlcType PlcType { get; }

Gets the detected PLC type.

Value: The PlcType value.

`T:IoT.Driver.OmronPlcRx.OmronConnectionOptions`

public class IoT.Driver.OmronPlcRx.OmronConnectionOptions

Configures an Omron PLC transport connection.

Declared public members

`M:IoT.Driver.OmronPlcRx.OmronConnectionOptions.#ctor(System.Byte,System.Byte,IoT.Driver.OmronPlcRx.Enums.ConnectionMethod,System.String)`

public IoT.Driver.OmronPlcRx.OmronConnectionOptions(byte localNodeId, byte remoteNodeId, IoT.Driver.OmronPlcRx.Enums.ConnectionMethod connectionMethod, string remoteHost)

Configures an Omron PLC transport connection.

Parameter localNodeId: Local FINS node identifier.
Parameter remoteNodeId: Remote PLC FINS node identifier.
Parameter connectionMethod: Transport to use.
Parameter remoteHost: PLC hostname, IP address, or serial port name.

`P:IoT.Driver.OmronPlcRx.OmronConnectionOptions.ConnectionMethod`

public IoT.Driver.OmronPlcRx.Enums.ConnectionMethod ConnectionMethod { get; }

Gets the transport to use.

Value: The ConnectionMethod value.

`P:IoT.Driver.OmronPlcRx.OmronConnectionOptions.LocalNodeId`

public byte LocalNodeId { get; }

Gets the local FINS node identifier.

Value: The LocalNodeId value.

`P:IoT.Driver.OmronPlcRx.OmronConnectionOptions.Port`

public int Port { get; set; }

Gets or initializes the network service port.

Value: The Port value.

`P:IoT.Driver.OmronPlcRx.OmronConnectionOptions.RemoteHost`

public string RemoteHost { get; }

Gets the PLC hostname, IP address, or serial port name.

Value: The RemoteHost value.

`P:IoT.Driver.OmronPlcRx.OmronConnectionOptions.RemoteNodeId`

public byte RemoteNodeId { get; }

Gets the remote PLC FINS node identifier.

Value: The RemoteNodeId value.

`P:IoT.Driver.OmronPlcRx.OmronConnectionOptions.Retries`

public int Retries { get; set; }

Gets or initializes the transient retry count.

Value: The Retries value.

`P:IoT.Driver.OmronPlcRx.OmronConnectionOptions.SerialOptions`

public IoT.Driver.OmronPlcRx.OmronSerialOptions SerialOptions { get; set; }

Gets or initializes serial transport settings.

Value: The SerialOptions value.

`P:IoT.Driver.OmronPlcRx.OmronConnectionOptions.Timeout`

public int Timeout { get; set; }

Gets or initializes the request timeout in milliseconds.

Value: The Timeout value.

`T:IoT.Driver.OmronPlcRx.OmronHostLinkFinsFrameMode`

public enum IoT.Driver.OmronPlcRx.OmronHostLinkFinsFrameMode

Specifies the Host Link FINS frame layout used over serial communications.

Declared public members

`F:IoT.Driver.OmronPlcRx.OmronHostLinkFinsFrameMode.Direct`

public static const IoT.Driver.OmronPlcRx.OmronHostLinkFinsFrameMode Direct

Directly connected host-computer-to-CPU format using ICF/DA2/SA2/SID fields.

`F:IoT.Driver.OmronPlcRx.OmronHostLinkFinsFrameMode.Network`

public static const IoT.Driver.OmronPlcRx.OmronHostLinkFinsFrameMode Network

Network-capable format using the complete FINS header.

`T:IoT.Driver.OmronPlcRx.OmronLogicalTagClient`

public class IoT.Driver.OmronPlcRx.OmronLogicalTagClient

Contains grouped FINS operations for the logical-tag client.

Declared public members

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.#ctor(IoT.Driver.OmronPlcRx.IOmronPlcRx)`

public IoT.Driver.OmronPlcRx.OmronLogicalTagClient(IoT.Driver.OmronPlcRx.IOmronPlcRx plc)

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.OmronLogicalTagClient class.

Parameter plc: Omron PLC facade used for protocol operations.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.#ctor(IoT.Driver.OmronPlcRx.IOmronPlcRx,IoT.Driver.Core.ILogicalTagCatalog)`

public IoT.Driver.OmronPlcRx.OmronLogicalTagClient(IoT.Driver.OmronPlcRx.IOmronPlcRx plc, IoT.Driver.Core.ILogicalTagCatalog catalog)

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.OmronLogicalTagClient class.

Parameter plc: Omron PLC facade used for protocol operations.
Parameter catalog: Logical-tag catalog.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.#ctor(IoT.Driver.OmronPlcRx.IOmronPlcRx,IoT.Driver.Core.ILogicalTagCatalog,IoT.Driver.Core.LogicalTagSqliteStore)`

public IoT.Driver.OmronPlcRx.OmronLogicalTagClient(IoT.Driver.OmronPlcRx.IOmronPlcRx plc, IoT.Driver.Core.ILogicalTagCatalog catalog, IoT.Driver.Core.LogicalTagSqliteStore store)

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.OmronLogicalTagClient class.

Parameter plc: Omron PLC facade used for protocol operations.
Parameter catalog: Logical-tag catalog.
Parameter store: Optional SQLite store.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.#ctor(IoT.Driver.OmronPlcRx.IOmronPlcRx,System.String)`

public IoT.Driver.OmronPlcRx.OmronLogicalTagClient(IoT.Driver.OmronPlcRx.IOmronPlcRx plc, string sqliteConnectionString)

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.OmronLogicalTagClient class.

Parameter plc: Omron PLC facade used for protocol operations.
Parameter sqliteConnectionString: SQLite connection string.

M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.CreateTag``1(IoT.Driver.OmronPlcRx.Tags.PlcTag1{``0})`

public IoT.Driver.Core.LogicalTag CreateTag<T>(IoT.Driver.OmronPlcRx.Tags.PlcTag<T> tag)

Executes the CreateTag operation.

Parameter tag: The tag value.
Returns: A IoT.Driver.Core.LogicalTag result.

M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.CreateTag``1(IoT.Driver.OmronPlcRx.Tags.PlcTag1{``0},System.String,System.String,System.Collections.Generic.IReadOnlyDictionary`2{System.String,System.String},IoT.Driver.Core.LogicalTagAccessMode,System.Nullable`1{System.TimeSpan})`

public IoT.Driver.Core.LogicalTag CreateTag<T>(IoT.Driver.OmronPlcRx.Tags.PlcTag<T> tag, string groupName, string description, System.Collections.Generic.IReadOnlyDictionary<string, string> metadata, IoT.Driver.Core.LogicalTagAccessMode accessMode, System.Nullable<System.TimeSpan> scanInterval)

Executes the CreateTag operation.

Parameter tag: The tag value.
Parameter groupName: The groupName value.
Parameter description: The description value.
Parameter metadata: The metadata value.
Parameter accessMode: The accessMode value.
Parameter scanInterval: The scanInterval value.
Returns: A IoT.Driver.Core.LogicalTag result.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.DeleteGroupAsync(System.String,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<bool> DeleteGroupAsync(string name, System.Threading.CancellationToken cancellationToken)

Deletes a persisted tag group.

Parameter name: Logical tag group name.
Parameter cancellationToken: Token used to cancel the operation.
Returns: True when the persisted group existed; otherwise false.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.DeleteTagAsync(System.String,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<bool> DeleteTagAsync(string name, System.Threading.CancellationToken cancellationToken)

Deletes a persisted and registered tag.

Parameter name: Logical tag name.
Parameter cancellationToken: Token used to cancel the operation.
Returns: True when the persisted tag existed; otherwise false.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.Dispose`

public void Dispose()

Inherits XML documentation from its implemented or overridden member.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.EditTagAsync(IoT.Driver.Core.LogicalTag,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<bool> EditTagAsync(IoT.Driver.Core.LogicalTag tag, System.Threading.CancellationToken cancellationToken)

Edits an existing persisted tag and refreshes its registration.

Parameter tag: Logical tag definition.
Parameter cancellationToken: Token used to cancel the operation.
Returns: True when the persisted tag existed; otherwise false.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.ExportCsvAsync(System.IO.TextWriter,System.Char,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task ExportCsvAsync(System.IO.TextWriter writer, char delimiter, System.Threading.CancellationToken cancellationToken)

Exports the current catalog as RFC 4180 CSV.

Parameter writer: CSV destination writer.
Parameter delimiter: CSV delimiter.
Parameter cancellationToken: Token used to cancel the export.
Returns: A task representing the export.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.GetGroupAsync(System.String,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<IoT.Driver.Core.LogicalTagGroup> GetGroupAsync(string name, System.Threading.CancellationToken cancellationToken)

Gets a persisted tag group.

Parameter name: Logical tag group name.
Parameter cancellationToken: Token used to cancel the query.
Returns: The matching group when present; otherwise null.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.GetTagAsync(System.String,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<IoT.Driver.Core.LogicalTag> GetTagAsync(string name, System.Threading.CancellationToken cancellationToken)

Gets a persisted tag by name.

Parameter name: Logical tag name.
Parameter cancellationToken: Token used to cancel the query.
Returns: The matching tag when present; otherwise null.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.ImportCsvAsync(System.IO.TextReader,System.Char,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<System.Collections.Generic.IReadOnlyList<IoT.Driver.Core.LogicalTag>> ImportCsvAsync(System.IO.TextReader reader, char delimiter, System.Threading.CancellationToken cancellationToken)

Imports RFC 4180 CSV definitions and registers them dynamically.

Parameter reader: CSV source reader.
Parameter delimiter: CSV delimiter.
Parameter cancellationToken: Token used to cancel the import.
Returns: The imported logical tags.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.InitializeStoreAsync(System.Threading.CancellationToken)`

public System.Threading.Tasks.Task InitializeStoreAsync(System.Threading.CancellationToken cancellationToken)

Initializes the configured SQLite store.

Parameter cancellationToken: Token used to cancel initialization.
Returns: A task representing initialization.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.ListGroupsAsync(System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<System.Collections.Generic.IReadOnlyList<IoT.Driver.Core.LogicalTagGroup>> ListGroupsAsync(System.Threading.CancellationToken cancellationToken)

Lists persisted tag groups.

Parameter cancellationToken: Token used to cancel the query.
Returns: The persisted groups.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.ListTagsAsync(System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<System.Collections.Generic.IReadOnlyList<IoT.Driver.Core.LogicalTag>> ListTagsAsync(System.Threading.CancellationToken cancellationToken)

Lists persisted tags.

Parameter cancellationToken: Token used to cancel the query.
Returns: The persisted logical tags.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.LoadTagsAsync(System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<System.Collections.Generic.IReadOnlyList<IoT.Driver.Core.LogicalTag>> LoadTagsAsync(System.Threading.CancellationToken cancellationToken)

Loads and dynamically registers all tags from the configured SQLite store.

Parameter cancellationToken: Token used to cancel the load.
Returns: The loaded logical tags.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.Observe(System.String)`

public System.IObservable<IoT.Driver.Core.LogicalTagValue> Observe(string tagName)

Inherits XML documentation from its implemented or overridden member.

Parameter tagName: The tagName value.
Returns: A System.IObservable<IoT.Driver.Core.LogicalTagValue> result.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.ObserveAsync(System.String,System.Threading.CancellationToken)`

public System.Collections.Generic.IAsyncEnumerable<IoT.Driver.Core.LogicalTagValue> ObserveAsync(string tagName, System.Threading.CancellationToken cancellationToken)

Inherits XML documentation from its implemented or overridden member.

Parameter tagName: The tagName value.
Parameter cancellationToken: The cancellationToken value.
Returns: A System.Collections.Generic.IAsyncEnumerable<IoT.Driver.Core.LogicalTagValue> result.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.ObserveMany(System.Collections.Generic.IReadOnlyCollection`1{System.String})`

public System.IObservable<IoT.Driver.Core.LogicalTagValue> ObserveMany(System.Collections.Generic.IReadOnlyCollection<string> tagNames)

Executes the ObserveMany operation.

Parameter tagNames: The tagNames value.
Returns: A System.IObservable<IoT.Driver.Core.LogicalTagValue> result.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.ObserveManyAsync(System.Collections.Generic.IReadOnlyCollection`1{System.String},System.Threading.CancellationToken)`

public System.Collections.Generic.IAsyncEnumerable<IoT.Driver.Core.LogicalTagValue> ObserveManyAsync(System.Collections.Generic.IReadOnlyCollection<string> tagNames, System.Threading.CancellationToken cancellationToken)

Executes the ObserveManyAsync operation.

Parameter tagNames: The tagNames value.
Parameter cancellationToken: The cancellationToken value.
Returns: A System.Collections.Generic.IAsyncEnumerable<IoT.Driver.Core.LogicalTagValue> result.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.ReadAsync(System.String,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<IoT.Driver.Core.TagOperationResult<IoT.Driver.Core.LogicalTagValue>> ReadAsync(string tagName, System.Threading.CancellationToken cancellationToken)

Inherits XML documentation from its implemented or overridden member.

Parameter tagName: The tagName value.
Parameter cancellationToken: The cancellationToken value.
Returns: A System.Threading.Tasks.Task<IoT.Driver.Core.TagOperationResult<IoT.Driver.Core.LogicalTagValue>> result.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.ReadManyAsync(System.Collections.Generic.IReadOnlyCollection`1{System.String},System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<System.Collections.Generic.IReadOnlyList<IoT.Driver.Core.TagOperationResult<IoT.Driver.Core.LogicalTagValue>>> ReadManyAsync(System.Collections.Generic.IReadOnlyCollection<string> tagNames, System.Threading.CancellationToken cancellationToken)

Executes the ReadManyAsync operation.

Parameter tagNames: The tagNames value.
Parameter cancellationToken: The cancellationToken value.
Returns: A System.Threading.Tasks.Task<System.Collections.Generic.IReadOnlyList<IoT.Driver.Core.TagOperationResult<IoT.Driver.Core.LogicalTagValue>>> result.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.RegisterTag(IoT.Driver.Core.LogicalTag)`

public void RegisterTag(IoT.Driver.Core.LogicalTag tag)

Registers or replaces a logical tag in both the Omron facade and catalog.

Parameter tag: Logical tag to register.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.RemoveTag(System.String)`

public bool RemoveTag(string name)

Removes a logical tag from the Omron facade and catalog.

Parameter name: Logical tag name.
Returns: True when either registration was removed; otherwise false.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.UpsertGroupAsync(IoT.Driver.Core.LogicalTagGroup,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task UpsertGroupAsync(IoT.Driver.Core.LogicalTagGroup group, System.Threading.CancellationToken cancellationToken)

Upserts a persisted tag group.

Parameter group: Logical tag group.
Parameter cancellationToken: Token used to cancel the operation.
Returns: A task representing the operation.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.UpsertTagAsync(IoT.Driver.Core.LogicalTag,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task UpsertTagAsync(IoT.Driver.Core.LogicalTag tag, System.Threading.CancellationToken cancellationToken)

Upserts a persisted tag and registers the resulting definition.

Parameter tag: Logical tag to upsert.
Parameter cancellationToken: Token used to cancel the operation.
Returns: A task representing the operation.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.WriteAsync(IoT.Driver.Core.LogicalTagValue,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<IoT.Driver.Core.TagOperationResult<IoT.Driver.Core.LogicalTagValue>> WriteAsync(IoT.Driver.Core.LogicalTagValue value, System.Threading.CancellationToken cancellationToken)

Inherits XML documentation from its implemented or overridden member.

Parameter value: The value value.
Parameter cancellationToken: The cancellationToken value.
Returns: A System.Threading.Tasks.Task<IoT.Driver.Core.TagOperationResult<IoT.Driver.Core.LogicalTagValue>> result.

`M:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.WriteManyAsync(System.Collections.Generic.IReadOnlyCollection`1{IoT.Driver.Core.LogicalTagValue},System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<System.Collections.Generic.IReadOnlyList<IoT.Driver.Core.TagOperationResult<IoT.Driver.Core.LogicalTagValue>>> WriteManyAsync(System.Collections.Generic.IReadOnlyCollection<IoT.Driver.Core.LogicalTagValue> values, System.Threading.CancellationToken cancellationToken)

Executes the WriteManyAsync operation.

Parameter values: The values value.
Parameter cancellationToken: The cancellationToken value.
Returns: A System.Threading.Tasks.Task<System.Collections.Generic.IReadOnlyList<IoT.Driver.Core.TagOperationResult<IoT.Driver.Core.LogicalTagValue>>> result.

`P:IoT.Driver.OmronPlcRx.OmronLogicalTagClient.Catalog`

public IoT.Driver.Core.ILogicalTagCatalog Catalog { get; }

Gets the logical-tag catalog composed by this client.

Value: The Catalog value.

`T:IoT.Driver.OmronPlcRx.OmronPLCException`

public class IoT.Driver.OmronPlcRx.OmronPLCException

Represents errors that occur during Omron PLC communication or processing.

Declared public members

`M:IoT.Driver.OmronPlcRx.OmronPLCException.#ctor`

public IoT.Driver.OmronPlcRx.OmronPLCException()

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.OmronPLCException class.

`M:IoT.Driver.OmronPlcRx.OmronPLCException.#ctor(System.String)`

public IoT.Driver.OmronPlcRx.OmronPLCException(string message)

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.OmronPLCException class.

Parameter message: The message that describes the error.

`M:IoT.Driver.OmronPlcRx.OmronPLCException.#ctor(System.String,System.Exception)`

public IoT.Driver.OmronPlcRx.OmronPLCException(string message, System.Exception innerException)

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.OmronPLCException class.

Parameter message: The error message that explains the reason for the exception.
Parameter innerException: The exception that is the cause of the current exception.

`T:IoT.Driver.OmronPlcRx.OmronPlcRx`

public class IoT.Driver.OmronPlcRx.OmronPlcRx

Contains PLC tag address parsing helpers.

Declared public members

`M:IoT.Driver.OmronPlcRx.OmronPlcRx.#ctor(IoT.Driver.OmronPlcRx.OmronConnectionOptions,System.Nullable`1{System.TimeSpan})`

public IoT.Driver.OmronPlcRx.OmronPlcRx(IoT.Driver.OmronPlcRx.OmronConnectionOptions options, System.Nullable<System.TimeSpan> pollInterval)

Initializes a new instance of IoT.Driver.OmronPlcRx.OmronPlcRx.

Parameter options: The options value.
Parameter pollInterval: The pollInterval value.

`M:IoT.Driver.OmronPlcRx.OmronPlcRx.#ctor(System.Byte,System.Byte,IoT.Driver.OmronPlcRx.OmronSerialOptions,System.Int32,System.Int32,System.Nullable`1{System.TimeSpan})`

public IoT.Driver.OmronPlcRx.OmronPlcRx(byte localNodeId, byte remoteNodeId, IoT.Driver.OmronPlcRx.OmronSerialOptions serialOptions, int timeout, int retries, System.Nullable<System.TimeSpan> pollInterval)

Initializes a new instance of IoT.Driver.OmronPlcRx.OmronPlcRx.

Parameter localNodeId: The localNodeId value.
Parameter remoteNodeId: The remoteNodeId value.
Parameter serialOptions: The serialOptions value.
Parameter timeout: The timeout value.
Parameter retries: The retries value.
Parameter pollInterval: The pollInterval value.

M:IoT.Driver.OmronPlcRx.OmronPlcRx.AddUpdateTagItem``1(IoT.Driver.OmronPlcRx.Tags.PlcTag1{``0})`

public void AddUpdateTagItem<T>(IoT.Driver.OmronPlcRx.Tags.PlcTag<T> tag)

Executes the AddUpdateTagItem operation.

Parameter tag: The tag value.

`M:IoT.Driver.OmronPlcRx.OmronPlcRx.Dispose`

public void Dispose()

Dispose pattern.

M:IoT.Driver.OmronPlcRx.OmronPlcRx.GetValue``1(IoT.Driver.Core.LogicalTagKey1{``0})`

public T GetValue<T>(IoT.Driver.Core.LogicalTagKey<T> tag)

Executes the GetValue operation.

Parameter tag: The tag value.
Returns: A T result.

M:IoT.Driver.OmronPlcRx.OmronPlcRx.Observe``1(IoT.Driver.Core.LogicalTagKey1{``0})`

public System.IObservable<T> Observe<T>(IoT.Driver.Core.LogicalTagKey<T> tag)

Executes the Observe operation.

Parameter tag: The tag value.
Returns: A System.IObservable<T> result.

`M:IoT.Driver.OmronPlcRx.OmronPlcRx.ReadClockAsync(System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<IoT.Driver.OmronPlcRx.Results.ReadClockResult> ReadClockAsync(System.Threading.CancellationToken cancellationToken)

Reads the PLC real-time clock via the underlying connection.

Parameter cancellationToken: Cancellation token.
Returns: Clock read result.

`M:IoT.Driver.OmronPlcRx.OmronPlcRx.ReadCycleTimeAsync(System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult> ReadCycleTimeAsync(System.Threading.CancellationToken cancellationToken)

Reads PLC scan cycle time statistics via the underlying connection.

Parameter cancellationToken: Cancellation token.
Returns: Cycle time statistics.

M:IoT.Driver.OmronPlcRx.OmronPlcRx.ReadValueAsync``1(IoT.Driver.Core.LogicalTagKey1{``0},System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<T> ReadValueAsync<T>(IoT.Driver.Core.LogicalTagKey<T> tag, System.Threading.CancellationToken cancellationToken)

Executes the ReadValueAsync operation.

Parameter tag: The tag value.
Parameter cancellationToken: The cancellationToken value.
Returns: A System.Threading.Tasks.Task<T> result.

`M:IoT.Driver.OmronPlcRx.OmronPlcRx.RemoveTagItem(System.String)`

public bool RemoveTagItem(string tagName)

Inherits XML documentation from its implemented or overridden member.

Parameter tagName: The tagName value.
Returns: A bool result.

M:IoT.Driver.OmronPlcRx.OmronPlcRx.SetValue``1(IoT.Driver.Core.LogicalTagKey1{`0},`0)`

public void SetValue<T>(IoT.Driver.Core.LogicalTagKey<T> tag, T value)

Executes the SetValue operation.

Parameter tag: The tag value.
Parameter value: The value value.

`M:IoT.Driver.OmronPlcRx.OmronPlcRx.WriteClockAsync(System.DateTimeOffset,System.Int32,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<IoT.Driver.OmronPlcRx.Results.WriteClockResult> WriteClockAsync(System.DateTimeOffset newDateTime, int newDayOfWeek, System.Threading.CancellationToken cancellationToken)

Writes the PLC real-time clock with explicit day-of-week via the underlying connection.

Parameter newDateTime: New date/time.
Parameter newDayOfWeek: Day of week (0-6).
Parameter cancellationToken: Cancellation token.
Returns: Clock write result.

`M:IoT.Driver.OmronPlcRx.OmronPlcRx.WriteClockAsync(System.DateTimeOffset,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<IoT.Driver.OmronPlcRx.Results.WriteClockResult> WriteClockAsync(System.DateTimeOffset newDateTime, System.Threading.CancellationToken cancellationToken)

Writes the PLC real-time clock (day-of-week inferred) via the underlying connection.

Parameter newDateTime: New date/time.
Parameter cancellationToken: Cancellation token.
Returns: Clock write result.

M:IoT.Driver.OmronPlcRx.OmronPlcRx.WriteValueAsync``1(IoT.Driver.Core.LogicalTagKey1{`0},`0,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task WriteValueAsync<T>(IoT.Driver.Core.LogicalTagKey<T> tag, T value, System.Threading.CancellationToken cancellationToken)

Executes the WriteValueAsync operation.

Parameter tag: The tag value.
Parameter value: The value value.
Parameter cancellationToken: The cancellationToken value.
Returns: A System.Threading.Tasks.Task result.

`P:IoT.Driver.OmronPlcRx.OmronPlcRx.ControllerModel`

public string ControllerModel { get; }

Gets the controller model value.

Value: The ControllerModel value.

`P:IoT.Driver.OmronPlcRx.OmronPlcRx.ControllerVersion`

public string ControllerVersion { get; }

Gets the controller version value.

Value: The ControllerVersion value.

`P:IoT.Driver.OmronPlcRx.OmronPlcRx.Errors`

public System.IObservable<IoT.Driver.OmronPlcRx.OmronPLCException> Errors { get; }

Inherits XML documentation from its implemented or overridden member.

Value: The Errors value.

`P:IoT.Driver.OmronPlcRx.OmronPlcRx.IsDisposed`

public bool IsDisposed { get; }

Inherits XML documentation from its implemented or overridden member.

Value: The IsDisposed value.

`P:IoT.Driver.OmronPlcRx.OmronPlcRx.ObserveAll`

public System.IObservable<IoT.Driver.OmronPlcRx.Tags.IPlcTag> ObserveAll { get; }

Inherits XML documentation from its implemented or overridden member.

Value: The ObserveAll value.

`P:IoT.Driver.OmronPlcRx.OmronPlcRx.PlcType`

public IoT.Driver.OmronPlcRx.Enums.PlcType PlcType { get; }

Gets the plc type value.

Value: The type of the PLC.

`T:IoT.Driver.OmronPlcRx.OmronPlcSimulator`

public class IoT.Driver.OmronPlcRx.OmronPlcSimulator

Provides a deterministic, in-memory Omron PLC through T:IoT.Driver.OmronPlcRx.IOmronPlcRx .

Declared public members

`M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.#ctor`

public IoT.Driver.OmronPlcRx.OmronPlcSimulator()

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.OmronPlcSimulator class.

`M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.#ctor(IoT.Driver.OmronPlcRx.Enums.PlcType,System.String,System.String,System.Boolean,System.DateTimeOffset)`

public IoT.Driver.OmronPlcRx.OmronPlcSimulator(IoT.Driver.OmronPlcRx.Enums.PlcType plcType, string controllerModel, string controllerVersion, bool initiallyConnected, System.DateTimeOffset initialClock)

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.OmronPlcSimulator class.

Parameter plcType: PLC model family reported to callers.
Parameter controllerModel: Controller model reported to callers.
Parameter controllerVersion: Controller version reported to callers.
Parameter initiallyConnected: Whether the simulated transport starts connected.
Parameter initialClock: Optional deterministic initial clock.

`M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.#ctor(System.Boolean)`

public IoT.Driver.OmronPlcRx.OmronPlcSimulator(bool initiallyConnected)

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.OmronPlcSimulator class.

Parameter initiallyConnected: Whether the simulated transport starts connected.

M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.AddUpdateTagItem``1(IoT.Driver.OmronPlcRx.Tags.PlcTag1{``0})`

public void AddUpdateTagItem<T>(IoT.Driver.OmronPlcRx.Tags.PlcTag<T> tag)

Executes the AddUpdateTagItem operation.

Parameter tag: The tag value.

`M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.ConnectAsync`

public System.Threading.Tasks.Task ConnectAsync()

Connects the simulated transport.

Returns: A task that represents the operation.

`M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.ConnectAsync(System.Threading.CancellationToken)`

public System.Threading.Tasks.Task ConnectAsync(System.Threading.CancellationToken cancellationToken)

Connects the simulated transport.

Parameter cancellationToken: Cancellation token.
Returns: A task that represents the operation.

`M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.Disconnect`

public void Disconnect()

Disconnects the simulated transport while retaining memory and registrations.

`M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.Dispose`

public void Dispose()

Inherits XML documentation from its implemented or overridden member.

M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.GetValue``1(IoT.Driver.Core.LogicalTagKey1{``0})`

public T GetValue<T>(IoT.Driver.Core.LogicalTagKey<T> tag)

Executes the GetValue operation.

Parameter tag: The tag value.
Returns: A T result.

M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.Observe``1(IoT.Driver.Core.LogicalTagKey1{``0})`

public System.IObservable<T> Observe<T>(IoT.Driver.Core.LogicalTagKey<T> tag)

Executes the Observe operation.

Parameter tag: The tag value.
Returns: A System.IObservable<T> result.

`M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.QueueFault(IoT.Driver.OmronPlcRx.OmronSimulatorOperation,System.Exception)`

public void QueueFault(IoT.Driver.OmronPlcRx.OmronSimulatorOperation operation, System.Exception exception)

Queues one disconnecting failure for the selected operation.

Parameter operation: Operation to fail.
Parameter exception: Failure to wrap and publish.

`M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.QueueFault(IoT.Driver.OmronPlcRx.OmronSimulatorOperation,System.Exception,System.Int32,System.Boolean)`

public void QueueFault(IoT.Driver.OmronPlcRx.OmronSimulatorOperation operation, System.Exception exception, int occurrences, bool disconnect)

Queues deterministic failures for the selected operation.

Parameter operation: Operation to fail.
Parameter exception: Failure to wrap and publish.
Parameter occurrences: Number of consecutive failures to queue.
Parameter disconnect: Whether each failure disconnects the simulated transport.

`M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.ReadClockAsync(System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<IoT.Driver.OmronPlcRx.Results.ReadClockResult> ReadClockAsync(System.Threading.CancellationToken cancellationToken)

Inherits XML documentation from its implemented or overridden member.

Parameter cancellationToken: The cancellationToken value.
Returns: A System.Threading.Tasks.Task<IoT.Driver.OmronPlcRx.Results.ReadClockResult> result.

`M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.ReadCycleTimeAsync(System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult> ReadCycleTimeAsync(System.Threading.CancellationToken cancellationToken)

Inherits XML documentation from its implemented or overridden member.

Parameter cancellationToken: The cancellationToken value.
Returns: A System.Threading.Tasks.Task<IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult> result.

M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.ReadValueAsync``1(IoT.Driver.Core.LogicalTagKey1{``0},System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<T> ReadValueAsync<T>(IoT.Driver.Core.LogicalTagKey<T> tag, System.Threading.CancellationToken cancellationToken)

Executes the ReadValueAsync operation.

Parameter tag: The tag value.
Parameter cancellationToken: The cancellationToken value.
Returns: A System.Threading.Tasks.Task<T> result.

`M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.ReconnectAsync`

public System.Threading.Tasks.Task ReconnectAsync()

Reconnects the simulated transport while retaining memory and registrations.

Returns: A task that represents the operation.

`M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.ReconnectAsync(System.Threading.CancellationToken)`

public System.Threading.Tasks.Task ReconnectAsync(System.Threading.CancellationToken cancellationToken)

Reconnects the simulated transport while retaining memory and registrations.

Parameter cancellationToken: Cancellation token.
Returns: A task that represents the operation.

`M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.RemoveTagItem(System.String)`

public bool RemoveTagItem(string tagName)

Inherits XML documentation from its implemented or overridden member.

Parameter tagName: The tagName value.
Returns: A bool result.

M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.Seed``1(IoT.Driver.OmronPlcRx.Tags.PlcTag1{`0},`0)`

public void Seed<T>(IoT.Driver.OmronPlcRx.Tags.PlcTag<T> tag, T value)

Executes the Seed operation.

Parameter tag: The tag value.
Parameter value: The value value.

M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.SetValue``1(IoT.Driver.Core.LogicalTagKey1{`0},`0)`

public void SetValue<T>(IoT.Driver.Core.LogicalTagKey<T> tag, T value)

Executes the SetValue operation.

Parameter tag: The tag value.
Parameter value: The value value.

`M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.WriteClockAsync(System.DateTimeOffset,System.Int32,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<IoT.Driver.OmronPlcRx.Results.WriteClockResult> WriteClockAsync(System.DateTimeOffset newDateTime, int newDayOfWeek, System.Threading.CancellationToken cancellationToken)

Inherits XML documentation from its implemented or overridden member.

Parameter newDateTime: The newDateTime value.
Parameter newDayOfWeek: The newDayOfWeek value.
Parameter cancellationToken: The cancellationToken value.
Returns: A System.Threading.Tasks.Task<IoT.Driver.OmronPlcRx.Results.WriteClockResult> result.

`M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.WriteClockAsync(System.DateTimeOffset,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task<IoT.Driver.OmronPlcRx.Results.WriteClockResult> WriteClockAsync(System.DateTimeOffset newDateTime, System.Threading.CancellationToken cancellationToken)

Inherits XML documentation from its implemented or overridden member.

Parameter newDateTime: The newDateTime value.
Parameter cancellationToken: The cancellationToken value.
Returns: A System.Threading.Tasks.Task<IoT.Driver.OmronPlcRx.Results.WriteClockResult> result.

M:IoT.Driver.OmronPlcRx.OmronPlcSimulator.WriteValueAsync``1(IoT.Driver.Core.LogicalTagKey1{`0},`0,System.Threading.CancellationToken)`

public System.Threading.Tasks.Task WriteValueAsync<T>(IoT.Driver.Core.LogicalTagKey<T> tag, T value, System.Threading.CancellationToken cancellationToken)

Executes the WriteValueAsync operation.

Parameter tag: The tag value.
Parameter value: The value value.
Parameter cancellationToken: The cancellationToken value.
Returns: A System.Threading.Tasks.Task result.

`P:IoT.Driver.OmronPlcRx.OmronPlcSimulator.AverageCycleTime`

public double AverageCycleTime { get; set; }

Gets or sets simulated average cycle time in milliseconds.

Value: The AverageCycleTime value.

`P:IoT.Driver.OmronPlcRx.OmronPlcSimulator.ControllerModel`

public string ControllerModel { get; }

Inherits XML documentation from its implemented or overridden member.

Value: The ControllerModel value.

`P:IoT.Driver.OmronPlcRx.OmronPlcSimulator.ControllerVersion`

public string ControllerVersion { get; }

Inherits XML documentation from its implemented or overridden member.

Value: The ControllerVersion value.

`P:IoT.Driver.OmronPlcRx.OmronPlcSimulator.Errors`

public System.IObservable<IoT.Driver.OmronPlcRx.OmronPLCException> Errors { get; }

Inherits XML documentation from its implemented or overridden member.

Value: The Errors value.

`P:IoT.Driver.OmronPlcRx.OmronPlcSimulator.IsConnected`

public bool IsConnected { get; }

Gets a value indicating whether the simulated transport is connected.

Value: The IsConnected value.

`P:IoT.Driver.OmronPlcRx.OmronPlcSimulator.IsDisposed`

public bool IsDisposed { get; }

Inherits XML documentation from its implemented or overridden member.

Value: The IsDisposed value.

`P:IoT.Driver.OmronPlcRx.OmronPlcSimulator.MaximumCycleTime`

public double MaximumCycleTime { get; set; }

Gets or sets simulated maximum cycle time in milliseconds.

Value: The MaximumCycleTime value.

`P:IoT.Driver.OmronPlcRx.OmronPlcSimulator.MinimumCycleTime`

public double MinimumCycleTime { get; set; }

Gets or sets simulated minimum cycle time in milliseconds.

Value: The MinimumCycleTime value.

`P:IoT.Driver.OmronPlcRx.OmronPlcSimulator.ObserveAll`

public System.IObservable<IoT.Driver.OmronPlcRx.Tags.IPlcTag> ObserveAll { get; }

Inherits XML documentation from its implemented or overridden member.

Value: The ObserveAll value.

`P:IoT.Driver.OmronPlcRx.OmronPlcSimulator.Operations`

public System.Collections.Generic.IReadOnlyList<IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord> Operations { get; }

Gets a snapshot of completed simulator operations.

Value: The Operations value.

`P:IoT.Driver.OmronPlcRx.OmronPlcSimulator.PlcType`

public IoT.Driver.OmronPlcRx.Enums.PlcType PlcType { get; }

Inherits XML documentation from its implemented or overridden member.

Value: The PlcType value.

`P:IoT.Driver.OmronPlcRx.OmronPlcSimulator.ReconnectCount`

public int ReconnectCount { get; }

Gets the number of successful reconnections.

Value: The ReconnectCount value.

`T:IoT.Driver.OmronPlcRx.OmronSerialOptions`

public class IoT.Driver.OmronPlcRx.OmronSerialOptions

Gets or sets the omron serial options value.

Declared public members

`M:IoT.Driver.OmronPlcRx.OmronSerialOptions.#ctor(System.String)`

public IoT.Driver.OmronPlcRx.OmronSerialOptions(string portName)

Initializes a new instance of the T:IoT.Driver.OmronPlcRx.OmronSerialOptions class.

Parameter portName: Serial port name, e.g. COM1 or /dev/ttyUSB0.

`M:IoT.Driver.OmronPlcRx.OmronSerialOptions.CreateToolbus(System.String)`

public static IoT.Driver.OmronPlcRx.OmronSerialOptions CreateToolbus(string portName)

Creates Toolbus serial options using common Omron Toolbus port settings.

Parameter portName: Serial port name, e.g. COM1 or /dev/ttyUSB0.
Returns: Serial options configured for Toolbus FINS framing.

`M:IoT.Driver.OmronPlcRx.OmronSerialOptions.Equals(IoT.Driver.OmronPlcRx.OmronSerialOptions)`

public bool Equals(IoT.Driver.OmronPlcRx.OmronSerialOptions other)

Determines whether the supplied value is equal to the current value.

Parameter other: The other value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.OmronSerialOptions.Equals(System.Object)`

public bool Equals(object obj)

Determines whether the supplied value is equal to the current value.

Parameter obj: The obj value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.OmronSerialOptions.GetHashCode`

public int GetHashCode()

Returns the hash code for the current value.

Returns: A int result.

`M:IoT.Driver.OmronPlcRx.OmronSerialOptions.ToString`

public string ToString()

Returns a string representation of the current value.

Returns: A string result.

`M:IoT.Driver.OmronPlcRx.OmronSerialOptions.Validate`

public void Validate()

Validates this options instance.

`M:IoT.Driver.OmronPlcRx.OmronSerialOptions.op_Equality(IoT.Driver.OmronPlcRx.OmronSerialOptions,IoT.Driver.OmronPlcRx.OmronSerialOptions)`

public static bool op_Equality(IoT.Driver.OmronPlcRx.OmronSerialOptions left, IoT.Driver.OmronPlcRx.OmronSerialOptions right)

Determines whether the two supplied values are equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.OmronSerialOptions.op_Inequality(IoT.Driver.OmronPlcRx.OmronSerialOptions,IoT.Driver.OmronPlcRx.OmronSerialOptions)`

public static bool op_Inequality(IoT.Driver.OmronPlcRx.OmronSerialOptions left, IoT.Driver.OmronPlcRx.OmronSerialOptions right)

Determines whether the two supplied values are not equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`P:IoT.Driver.OmronPlcRx.OmronSerialOptions.BaudRate`

public int BaudRate { get; set; }

Gets or sets the baud rate value.

Value: The BaudRate value.

`P:IoT.Driver.OmronPlcRx.OmronSerialOptions.DataBits`

public int DataBits { get; set; }

Gets or sets the data bits value.

Value: The DataBits value.

`P:IoT.Driver.OmronPlcRx.OmronSerialOptions.DtrEnable`

public bool DtrEnable { get; set; }

Gets or sets the dtr enable value.

Value: The DtrEnable value.

`P:IoT.Driver.OmronPlcRx.OmronSerialOptions.FrameMode`

public IoT.Driver.OmronPlcRx.OmronHostLinkFinsFrameMode FrameMode { get; set; }

Gets or sets the frame mode value.

Value: The FrameMode value.

`P:IoT.Driver.OmronPlcRx.OmronSerialOptions.Handshake`

public System.IO.Ports.Handshake Handshake { get; set; }

Gets or sets the handshake value.

Value: The Handshake value.

`P:IoT.Driver.OmronPlcRx.OmronSerialOptions.HostLinkUnitNumber`

public byte HostLinkUnitNumber { get; set; }

Gets or sets the host link unit number value.

Value: The HostLinkUnitNumber value.

`P:IoT.Driver.OmronPlcRx.OmronSerialOptions.MaximumFrameLength`

public int MaximumFrameLength { get; set; }

Gets or sets the maximum frame length value.

Value: The MaximumFrameLength value.

`P:IoT.Driver.OmronPlcRx.OmronSerialOptions.Parity`

public System.IO.Ports.Parity Parity { get; set; }

Gets or sets the parity value.

Value: The Parity value.

`P:IoT.Driver.OmronPlcRx.OmronSerialOptions.PortName`

public string PortName { get; set; }

Gets or sets the port name value.

Value: The PortName value.

`P:IoT.Driver.OmronPlcRx.OmronSerialOptions.Protocol`

public IoT.Driver.OmronPlcRx.OmronSerialProtocol Protocol { get; set; }

Gets or sets the protocol value.

Value: The Protocol value.

`P:IoT.Driver.OmronPlcRx.OmronSerialOptions.ResponseWaitTime`

public byte ResponseWaitTime { get; set; }

Gets or sets the response wait time value.

Value: The ResponseWaitTime value.

`P:IoT.Driver.OmronPlcRx.OmronSerialOptions.RtsEnable`

public bool RtsEnable { get; set; }

Gets or sets the rts enable value.

Value: The RtsEnable value.

`P:IoT.Driver.OmronPlcRx.OmronSerialOptions.StopBits`

public System.IO.Ports.StopBits StopBits { get; set; }

Gets or sets the stop bits value.

Value: The StopBits value.

`T:IoT.Driver.OmronPlcRx.OmronSerialProtocol`

public enum IoT.Driver.OmronPlcRx.OmronSerialProtocol

Specifies the serial protocol used to carry FINS messages.

Declared public members

`F:IoT.Driver.OmronPlcRx.OmronSerialProtocol.HostLinkFins`

public static const IoT.Driver.OmronPlcRx.OmronSerialProtocol HostLinkFins

Host Link FINS using ASCII FA frames.

`F:IoT.Driver.OmronPlcRx.OmronSerialProtocol.Toolbus`

public static const IoT.Driver.OmronPlcRx.OmronSerialProtocol Toolbus

Omron Toolbus using binary 0xAB frames carrying binary FINS messages.

`T:IoT.Driver.OmronPlcRx.OmronSimulatorOperation`

public enum IoT.Driver.OmronPlcRx.OmronSimulatorOperation

Identifies an operation that can be faulted by T:IoT.Driver.OmronPlcRx.OmronPlcSimulator .

Declared public members

`F:IoT.Driver.OmronPlcRx.OmronSimulatorOperation.Connect`

public static const IoT.Driver.OmronPlcRx.OmronSimulatorOperation Connect

Opening or reopening the simulated connection.

`F:IoT.Driver.OmronPlcRx.OmronSimulatorOperation.Read`

public static const IoT.Driver.OmronPlcRx.OmronSimulatorOperation Read

Reading a registered tag.

`F:IoT.Driver.OmronPlcRx.OmronSimulatorOperation.ReadClock`

public static const IoT.Driver.OmronPlcRx.OmronSimulatorOperation ReadClock

Reading the simulated real-time clock.

`F:IoT.Driver.OmronPlcRx.OmronSimulatorOperation.ReadCycleTime`

public static const IoT.Driver.OmronPlcRx.OmronSimulatorOperation ReadCycleTime

Reading simulated cycle-time statistics.

`F:IoT.Driver.OmronPlcRx.OmronSimulatorOperation.Write`

public static const IoT.Driver.OmronPlcRx.OmronSimulatorOperation Write

Writing a registered tag.

`F:IoT.Driver.OmronPlcRx.OmronSimulatorOperation.WriteClock`

public static const IoT.Driver.OmronPlcRx.OmronSimulatorOperation WriteClock

Writing the simulated real-time clock.

`T:IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord`

public class IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord

Describes one completed simulator operation.

Declared public members

`M:IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord.#ctor(System.Int64,IoT.Driver.OmronPlcRx.OmronSimulatorOperation,System.String,System.Object,System.Boolean)`

public IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord(long Sequence, IoT.Driver.OmronPlcRx.OmronSimulatorOperation Operation, string TagName, object Value, bool Succeeded)

Describes one completed simulator operation.

Parameter Sequence: Monotonic operation sequence number.
Parameter Operation: Operation kind.
Parameter TagName: Optional logical tag name.
Parameter Value: Optional operation value.
Parameter Succeeded: Whether the operation succeeded.

`M:IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord.Deconstruct(System.Int64@,IoT.Driver.OmronPlcRx.OmronSimulatorOperation@,System.String@,System.Object@,System.Boolean@)`

public void Deconstruct(out long Sequence, out IoT.Driver.OmronPlcRx.OmronSimulatorOperation Operation, out string TagName, out object Value, out bool Succeeded)

Deconstructs the value into its component values.

Parameter Sequence: The Sequence value.
Parameter Operation: The Operation value.
Parameter TagName: The TagName value.
Parameter Value: The Value value.
Parameter Succeeded: The Succeeded value.

`M:IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord.Equals(IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord)`

public bool Equals(IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord other)

Determines whether the supplied value is equal to the current value.

Parameter other: The other value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord.Equals(System.Object)`

public bool Equals(object obj)

Determines whether the supplied value is equal to the current value.

Parameter obj: The obj value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord.GetHashCode`

public int GetHashCode()

Returns the hash code for the current value.

Returns: A int result.

`M:IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord.ToString`

public string ToString()

Returns a string representation of the current value.

Returns: A string result.

`M:IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord.op_Equality(IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord,IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord)`

public static bool op_Equality(IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord left, IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord right)

Determines whether the two supplied values are equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord.op_Inequality(IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord,IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord)`

public static bool op_Inequality(IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord left, IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord right)

Determines whether the two supplied values are not equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`P:IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord.Operation`

public IoT.Driver.OmronPlcRx.OmronSimulatorOperation Operation { get; set; }

Operation kind.

Value: The Operation value.

`P:IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord.Sequence`

public long Sequence { get; set; }

Monotonic operation sequence number.

Value: The Sequence value.

`P:IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord.Succeeded`

public bool Succeeded { get; set; }

Whether the operation succeeded.

Value: The Succeeded value.

`P:IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord.TagName`

public string TagName { get; set; }

Optional logical tag name.

Value: The TagName value.

`P:IoT.Driver.OmronPlcRx.OmronSimulatorOperationRecord.Value`

public object Value { get; set; }

Optional operation value.

Value: The Value value.

`T:IoT.Driver.OmronPlcRx.PlcTagAttribute`

public class IoT.Driver.OmronPlcRx.PlcTagAttribute

Marks a field or property for PLC reactive stream source generation.

Declared public members

`M:IoT.Driver.OmronPlcRx.PlcTagAttribute.#ctor(System.String)`

public IoT.Driver.OmronPlcRx.PlcTagAttribute(string address)

Marks a field or property for PLC reactive stream source generation.

Parameter address: The a dd re ss value.

`P:IoT.Driver.OmronPlcRx.PlcTagAttribute.Address`

public string Address { get; }

Gets the address value.

Value: The Address value.

`P:IoT.Driver.OmronPlcRx.PlcTagAttribute.Observe`

public bool Observe { get; set; }

Gets or sets the observe value.

Value: The Observe value.

`P:IoT.Driver.OmronPlcRx.PlcTagAttribute.Register`

public bool Register { get; set; }

Gets or sets the register value.

Value: The Register value.

`P:IoT.Driver.OmronPlcRx.PlcTagAttribute.TagName`

public string TagName { get; set; }

Gets or sets the tag name value.

Value: The TagName value.

`P:IoT.Driver.OmronPlcRx.PlcTagAttribute.Writable`

public bool Writable { get; set; }

Gets or sets the writable value.

Value: The Writable value.

`T:IoT.Driver.OmronPlcRx.PlcTagBindingAttribute`

public class IoT.Driver.OmronPlcRx.PlcTagBindingAttribute

Marks a partial class as a generated PLC tag binding container.

Declared public members

`M:IoT.Driver.OmronPlcRx.PlcTagBindingAttribute.#ctor`

public IoT.Driver.OmronPlcRx.PlcTagBindingAttribute()

Initializes a new instance of IoT.Driver.OmronPlcRx.PlcTagBindingAttribute.

`T:IoT.Driver.OmronPlcRx.Results.ReadBitsResult`

public struct IoT.Driver.OmronPlcRx.Results.ReadBitsResult

Result of a Read Bits operation.

Declared public members

`M:IoT.Driver.OmronPlcRx.Results.ReadBitsResult.Equals(IoT.Driver.OmronPlcRx.Results.ReadBitsResult)`

public bool Equals(IoT.Driver.OmronPlcRx.Results.ReadBitsResult other)

Determines whether the supplied value is equal to the current value.

Parameter other: The other value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.ReadBitsResult.Equals(System.Object)`

public bool Equals(object obj)

Determines whether the supplied value is equal to the current value.

Parameter obj: The obj value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.ReadBitsResult.GetHashCode`

public int GetHashCode()

Returns the hash code for the current value.

Returns: A int result.

`M:IoT.Driver.OmronPlcRx.Results.ReadBitsResult.ToString`

public string ToString()

Returns a string representation of the current value.

Returns: A string result.

`M:IoT.Driver.OmronPlcRx.Results.ReadBitsResult.op_Equality(IoT.Driver.OmronPlcRx.Results.ReadBitsResult,IoT.Driver.OmronPlcRx.Results.ReadBitsResult)`

public static bool op_Equality(IoT.Driver.OmronPlcRx.Results.ReadBitsResult left, IoT.Driver.OmronPlcRx.Results.ReadBitsResult right)

Determines whether the two supplied values are equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.ReadBitsResult.op_Inequality(IoT.Driver.OmronPlcRx.Results.ReadBitsResult,IoT.Driver.OmronPlcRx.Results.ReadBitsResult)`

public static bool op_Inequality(IoT.Driver.OmronPlcRx.Results.ReadBitsResult left, IoT.Driver.OmronPlcRx.Results.ReadBitsResult right)

Determines whether the two supplied values are not equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`P:IoT.Driver.OmronPlcRx.Results.ReadBitsResult.BytesReceived`

public int BytesReceived { get; set; }

Gets or sets the bytes received value.

Value: The BytesReceived value.

`P:IoT.Driver.OmronPlcRx.Results.ReadBitsResult.BytesSent`

public int BytesSent { get; set; }

Gets or sets the bytes sent value.

Value: The BytesSent value.

`P:IoT.Driver.OmronPlcRx.Results.ReadBitsResult.Duration`

public double Duration { get; set; }

Gets or sets the duration value.

Value: The Duration value.

`P:IoT.Driver.OmronPlcRx.Results.ReadBitsResult.PacketsReceived`

public int PacketsReceived { get; set; }

Gets or sets the packets received value.

Value: The PacketsReceived value.

`P:IoT.Driver.OmronPlcRx.Results.ReadBitsResult.PacketsSent`

public int PacketsSent { get; set; }

Gets or sets the packets sent value.

Value: The PacketsSent value.

`P:IoT.Driver.OmronPlcRx.Results.ReadBitsResult.Values`

public bool[] Values { get; set; }

Gets or sets the values value.

Value: The Values value.

`T:IoT.Driver.OmronPlcRx.Results.ReadClockResult`

public struct IoT.Driver.OmronPlcRx.Results.ReadClockResult

Result of a Read Clock operation.

Declared public members

`M:IoT.Driver.OmronPlcRx.Results.ReadClockResult.Equals(IoT.Driver.OmronPlcRx.Results.ReadClockResult)`

public bool Equals(IoT.Driver.OmronPlcRx.Results.ReadClockResult other)

Determines whether the supplied value is equal to the current value.

Parameter other: The other value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.ReadClockResult.Equals(System.Object)`

public bool Equals(object obj)

Determines whether the supplied value is equal to the current value.

Parameter obj: The obj value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.ReadClockResult.GetHashCode`

public int GetHashCode()

Returns the hash code for the current value.

Returns: A int result.

`M:IoT.Driver.OmronPlcRx.Results.ReadClockResult.ToString`

public string ToString()

Returns a string representation of the current value.

Returns: A string result.

`M:IoT.Driver.OmronPlcRx.Results.ReadClockResult.op_Equality(IoT.Driver.OmronPlcRx.Results.ReadClockResult,IoT.Driver.OmronPlcRx.Results.ReadClockResult)`

public static bool op_Equality(IoT.Driver.OmronPlcRx.Results.ReadClockResult left, IoT.Driver.OmronPlcRx.Results.ReadClockResult right)

Determines whether the two supplied values are equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.ReadClockResult.op_Inequality(IoT.Driver.OmronPlcRx.Results.ReadClockResult,IoT.Driver.OmronPlcRx.Results.ReadClockResult)`

public static bool op_Inequality(IoT.Driver.OmronPlcRx.Results.ReadClockResult left, IoT.Driver.OmronPlcRx.Results.ReadClockResult right)

Determines whether the two supplied values are not equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`P:IoT.Driver.OmronPlcRx.Results.ReadClockResult.BytesReceived`

public int BytesReceived { get; set; }

Gets or sets the bytes received value.

Value: The BytesReceived value.

`P:IoT.Driver.OmronPlcRx.Results.ReadClockResult.BytesSent`

public int BytesSent { get; set; }

Gets or sets the bytes sent value.

Value: The BytesSent value.

`P:IoT.Driver.OmronPlcRx.Results.ReadClockResult.Clock`

public System.DateTimeOffset Clock { get; set; }

Gets or sets the clock value.

Value: The Clock value.

`P:IoT.Driver.OmronPlcRx.Results.ReadClockResult.DayOfWeek`

public int DayOfWeek { get; set; }

Gets or sets the day of week value.

Value: The DayOfWeek value.

`P:IoT.Driver.OmronPlcRx.Results.ReadClockResult.Duration`

public double Duration { get; set; }

Gets or sets the duration value.

Value: The Duration value.

`P:IoT.Driver.OmronPlcRx.Results.ReadClockResult.PacketsReceived`

public int PacketsReceived { get; set; }

Gets or sets the packets received value.

Value: The PacketsReceived value.

`P:IoT.Driver.OmronPlcRx.Results.ReadClockResult.PacketsSent`

public int PacketsSent { get; set; }

Gets or sets the packets sent value.

Value: The PacketsSent value.

`T:IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult`

public struct IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult

Result of a Read Cycle Time operation.

Declared public members

`M:IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult.Equals(IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult)`

public bool Equals(IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult other)

Determines whether the supplied value is equal to the current value.

Parameter other: The other value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult.Equals(System.Object)`

public bool Equals(object obj)

Determines whether the supplied value is equal to the current value.

Parameter obj: The obj value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult.GetHashCode`

public int GetHashCode()

Returns the hash code for the current value.

Returns: A int result.

`M:IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult.ToString`

public string ToString()

Returns a string representation of the current value.

Returns: A string result.

`M:IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult.op_Equality(IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult,IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult)`

public static bool op_Equality(IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult left, IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult right)

Determines whether the two supplied values are equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult.op_Inequality(IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult,IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult)`

public static bool op_Inequality(IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult left, IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult right)

Determines whether the two supplied values are not equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`P:IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult.AverageCycleTime`

public double AverageCycleTime { get; set; }

Gets or sets the average cycle time value.

Value: The AverageCycleTime value.

`P:IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult.BytesReceived`

public int BytesReceived { get; set; }

Gets or sets the bytes received value.

Value: The BytesReceived value.

`P:IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult.BytesSent`

public int BytesSent { get; set; }

Gets or sets the bytes sent value.

Value: The BytesSent value.

`P:IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult.Duration`

public double Duration { get; set; }

Gets or sets the duration value.

Value: The Duration value.

`P:IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult.MaximumCycleTime`

public double MaximumCycleTime { get; set; }

Gets or sets the maximum cycle time value.

Value: The MaximumCycleTime value.

`P:IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult.MinimumCycleTime`

public double MinimumCycleTime { get; set; }

Gets or sets the minimum cycle time value.

Value: The MinimumCycleTime value.

`P:IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult.PacketsReceived`

public int PacketsReceived { get; set; }

Gets or sets the packets received value.

Value: The PacketsReceived value.

`P:IoT.Driver.OmronPlcRx.Results.ReadCycleTimeResult.PacketsSent`

public int PacketsSent { get; set; }

Gets or sets the packets sent value.

Value: The PacketsSent value.

`T:IoT.Driver.OmronPlcRx.Results.ReadWordsResult`

public struct IoT.Driver.OmronPlcRx.Results.ReadWordsResult

Result of a Read Words operation.

Declared public members

`M:IoT.Driver.OmronPlcRx.Results.ReadWordsResult.Equals(IoT.Driver.OmronPlcRx.Results.ReadWordsResult)`

public bool Equals(IoT.Driver.OmronPlcRx.Results.ReadWordsResult other)

Determines whether the supplied value is equal to the current value.

Parameter other: The other value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.ReadWordsResult.Equals(System.Object)`

public bool Equals(object obj)

Determines whether the supplied value is equal to the current value.

Parameter obj: The obj value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.ReadWordsResult.GetHashCode`

public int GetHashCode()

Returns the hash code for the current value.

Returns: A int result.

`M:IoT.Driver.OmronPlcRx.Results.ReadWordsResult.ToString`

public string ToString()

Returns a string representation of the current value.

Returns: A string result.

`M:IoT.Driver.OmronPlcRx.Results.ReadWordsResult.op_Equality(IoT.Driver.OmronPlcRx.Results.ReadWordsResult,IoT.Driver.OmronPlcRx.Results.ReadWordsResult)`

public static bool op_Equality(IoT.Driver.OmronPlcRx.Results.ReadWordsResult left, IoT.Driver.OmronPlcRx.Results.ReadWordsResult right)

Determines whether the two supplied values are equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.ReadWordsResult.op_Inequality(IoT.Driver.OmronPlcRx.Results.ReadWordsResult,IoT.Driver.OmronPlcRx.Results.ReadWordsResult)`

public static bool op_Inequality(IoT.Driver.OmronPlcRx.Results.ReadWordsResult left, IoT.Driver.OmronPlcRx.Results.ReadWordsResult right)

Determines whether the two supplied values are not equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`P:IoT.Driver.OmronPlcRx.Results.ReadWordsResult.BytesReceived`

public int BytesReceived { get; set; }

Gets or sets the bytes received value.

Value: The BytesReceived value.

`P:IoT.Driver.OmronPlcRx.Results.ReadWordsResult.BytesSent`

public int BytesSent { get; set; }

Gets or sets the bytes sent value.

Value: The BytesSent value.

`P:IoT.Driver.OmronPlcRx.Results.ReadWordsResult.Duration`

public double Duration { get; set; }

Gets or sets the duration value.

Value: The Duration value.

`P:IoT.Driver.OmronPlcRx.Results.ReadWordsResult.PacketsReceived`

public int PacketsReceived { get; set; }

Gets or sets the packets received value.

Value: The PacketsReceived value.

`P:IoT.Driver.OmronPlcRx.Results.ReadWordsResult.PacketsSent`

public int PacketsSent { get; set; }

Gets or sets the packets sent value.

Value: The PacketsSent value.

`P:IoT.Driver.OmronPlcRx.Results.ReadWordsResult.Values`

public short[] Values { get; set; }

Gets or sets the values value.

Value: The Values value.

`T:IoT.Driver.OmronPlcRx.Results.WriteBitsResult`

public struct IoT.Driver.OmronPlcRx.Results.WriteBitsResult

Result of a Write Bits operation.

Declared public members

`M:IoT.Driver.OmronPlcRx.Results.WriteBitsResult.Equals(IoT.Driver.OmronPlcRx.Results.WriteBitsResult)`

public bool Equals(IoT.Driver.OmronPlcRx.Results.WriteBitsResult other)

Determines whether the supplied value is equal to the current value.

Parameter other: The other value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.WriteBitsResult.Equals(System.Object)`

public bool Equals(object obj)

Determines whether the supplied value is equal to the current value.

Parameter obj: The obj value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.WriteBitsResult.GetHashCode`

public int GetHashCode()

Returns the hash code for the current value.

Returns: A int result.

`M:IoT.Driver.OmronPlcRx.Results.WriteBitsResult.ToString`

public string ToString()

Returns a string representation of the current value.

Returns: A string result.

`M:IoT.Driver.OmronPlcRx.Results.WriteBitsResult.op_Equality(IoT.Driver.OmronPlcRx.Results.WriteBitsResult,IoT.Driver.OmronPlcRx.Results.WriteBitsResult)`

public static bool op_Equality(IoT.Driver.OmronPlcRx.Results.WriteBitsResult left, IoT.Driver.OmronPlcRx.Results.WriteBitsResult right)

Determines whether the two supplied values are equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.WriteBitsResult.op_Inequality(IoT.Driver.OmronPlcRx.Results.WriteBitsResult,IoT.Driver.OmronPlcRx.Results.WriteBitsResult)`

public static bool op_Inequality(IoT.Driver.OmronPlcRx.Results.WriteBitsResult left, IoT.Driver.OmronPlcRx.Results.WriteBitsResult right)

Determines whether the two supplied values are not equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`P:IoT.Driver.OmronPlcRx.Results.WriteBitsResult.BytesReceived`

public int BytesReceived { get; set; }

Gets or sets the bytes received value.

Value: The BytesReceived value.

`P:IoT.Driver.OmronPlcRx.Results.WriteBitsResult.BytesSent`

public int BytesSent { get; set; }

Gets or sets the bytes sent value.

Value: The BytesSent value.

`P:IoT.Driver.OmronPlcRx.Results.WriteBitsResult.Duration`

public double Duration { get; set; }

Gets or sets the duration value.

Value: The Duration value.

`P:IoT.Driver.OmronPlcRx.Results.WriteBitsResult.PacketsReceived`

public int PacketsReceived { get; set; }

Gets or sets the packets received value.

Value: The PacketsReceived value.

`P:IoT.Driver.OmronPlcRx.Results.WriteBitsResult.PacketsSent`

public int PacketsSent { get; set; }

Gets or sets the packets sent value.

Value: The PacketsSent value.

`T:IoT.Driver.OmronPlcRx.Results.WriteClockResult`

public struct IoT.Driver.OmronPlcRx.Results.WriteClockResult

Result of a Write Clock operation.

Declared public members

`M:IoT.Driver.OmronPlcRx.Results.WriteClockResult.Equals(IoT.Driver.OmronPlcRx.Results.WriteClockResult)`

public bool Equals(IoT.Driver.OmronPlcRx.Results.WriteClockResult other)

Determines whether the supplied value is equal to the current value.

Parameter other: The other value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.WriteClockResult.Equals(System.Object)`

public bool Equals(object obj)

Determines whether the supplied value is equal to the current value.

Parameter obj: The obj value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.WriteClockResult.GetHashCode`

public int GetHashCode()

Returns the hash code for the current value.

Returns: A int result.

`M:IoT.Driver.OmronPlcRx.Results.WriteClockResult.ToString`

public string ToString()

Returns a string representation of the current value.

Returns: A string result.

`M:IoT.Driver.OmronPlcRx.Results.WriteClockResult.op_Equality(IoT.Driver.OmronPlcRx.Results.WriteClockResult,IoT.Driver.OmronPlcRx.Results.WriteClockResult)`

public static bool op_Equality(IoT.Driver.OmronPlcRx.Results.WriteClockResult left, IoT.Driver.OmronPlcRx.Results.WriteClockResult right)

Determines whether the two supplied values are equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.WriteClockResult.op_Inequality(IoT.Driver.OmronPlcRx.Results.WriteClockResult,IoT.Driver.OmronPlcRx.Results.WriteClockResult)`

public static bool op_Inequality(IoT.Driver.OmronPlcRx.Results.WriteClockResult left, IoT.Driver.OmronPlcRx.Results.WriteClockResult right)

Determines whether the two supplied values are not equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`P:IoT.Driver.OmronPlcRx.Results.WriteClockResult.BytesReceived`

public int BytesReceived { get; set; }

Gets or sets the bytes received value.

Value: The BytesReceived value.

`P:IoT.Driver.OmronPlcRx.Results.WriteClockResult.BytesSent`

public int BytesSent { get; set; }

Gets or sets the bytes sent value.

Value: The BytesSent value.

`P:IoT.Driver.OmronPlcRx.Results.WriteClockResult.Duration`

public double Duration { get; set; }

Gets or sets the duration value.

Value: The Duration value.

`P:IoT.Driver.OmronPlcRx.Results.WriteClockResult.PacketsReceived`

public int PacketsReceived { get; set; }

Gets or sets the packets received value.

Value: The PacketsReceived value.

`P:IoT.Driver.OmronPlcRx.Results.WriteClockResult.PacketsSent`

public int PacketsSent { get; set; }

Gets or sets the packets sent value.

Value: The PacketsSent value.

`T:IoT.Driver.OmronPlcRx.Results.WriteWordsResult`

public struct IoT.Driver.OmronPlcRx.Results.WriteWordsResult

Result of a Write Words operation.

Declared public members

`M:IoT.Driver.OmronPlcRx.Results.WriteWordsResult.Equals(IoT.Driver.OmronPlcRx.Results.WriteWordsResult)`

public bool Equals(IoT.Driver.OmronPlcRx.Results.WriteWordsResult other)

Determines whether the supplied value is equal to the current value.

Parameter other: The other value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.WriteWordsResult.Equals(System.Object)`

public bool Equals(object obj)

Determines whether the supplied value is equal to the current value.

Parameter obj: The obj value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.WriteWordsResult.GetHashCode`

public int GetHashCode()

Returns the hash code for the current value.

Returns: A int result.

`M:IoT.Driver.OmronPlcRx.Results.WriteWordsResult.ToString`

public string ToString()

Returns a string representation of the current value.

Returns: A string result.

`M:IoT.Driver.OmronPlcRx.Results.WriteWordsResult.op_Equality(IoT.Driver.OmronPlcRx.Results.WriteWordsResult,IoT.Driver.OmronPlcRx.Results.WriteWordsResult)`

public static bool op_Equality(IoT.Driver.OmronPlcRx.Results.WriteWordsResult left, IoT.Driver.OmronPlcRx.Results.WriteWordsResult right)

Determines whether the two supplied values are equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`M:IoT.Driver.OmronPlcRx.Results.WriteWordsResult.op_Inequality(IoT.Driver.OmronPlcRx.Results.WriteWordsResult,IoT.Driver.OmronPlcRx.Results.WriteWordsResult)`

public static bool op_Inequality(IoT.Driver.OmronPlcRx.Results.WriteWordsResult left, IoT.Driver.OmronPlcRx.Results.WriteWordsResult right)

Determines whether the two supplied values are not equal.

Parameter left: The left value.
Parameter right: The right value.
Returns: A bool result.

`P:IoT.Driver.OmronPlcRx.Results.WriteWordsResult.BytesReceived`

public int BytesReceived { get; set; }

Gets or sets the bytes received value.

Value: The BytesReceived value.

`P:IoT.Driver.OmronPlcRx.Results.WriteWordsResult.BytesSent`

public int BytesSent { get; set; }

Gets or sets the bytes sent value.

Value: The BytesSent value.

`P:IoT.Driver.OmronPlcRx.Results.WriteWordsResult.Duration`

public double Duration { get; set; }

Gets or sets the duration value.

Value: The Duration value.

`P:IoT.Driver.OmronPlcRx.Results.WriteWordsResult.PacketsReceived`

public int PacketsReceived { get; set; }

Gets or sets the packets received value.

Value: The PacketsReceived value.

`P:IoT.Driver.OmronPlcRx.Results.WriteWordsResult.PacketsSent`

public int PacketsSent { get; set; }

Gets or sets the packets sent value.

Value: The PacketsSent value.

`T:IoT.Driver.OmronPlcRx.Tags.IPlcTag`

public interface IoT.Driver.OmronPlcRx.Tags.IPlcTag

Defines metadata and value access for a PLC tag.

Declared public members

`P:IoT.Driver.OmronPlcRx.Tags.IPlcTag.Address`

public string Address { get; }

Gets the address.

Value: The address.

`P:IoT.Driver.OmronPlcRx.Tags.IPlcTag.TagName`

public string TagName { get; }

Gets the name of the tag.

Value: The name of the tag.

`P:IoT.Driver.OmronPlcRx.Tags.IPlcTag.TagType`

public System.Type TagType { get; }

Gets a value indicating whether this instance is bit address.

Value: true if this instance is bit address; otherwise, false .

`P:IoT.Driver.OmronPlcRx.Tags.IPlcTag.Value`

public object Value { get; }

Gets the value.

Value: The value.

`T:IoT.Driver.OmronPlcRx.Tags.PlcTag`1`

public class IoT.Driver.OmronPlcRx.Tags.PlcTag`1

Represents a typed PLC tag binding.

Declared public members

`M:IoT.Driver.OmronPlcRx.Tags.PlcTag`1.#ctor(System.String,System.String)`

public IoT.Driver.OmronPlcRx.Tags.PlcTag<T>(string tagName, string address)

Represents a typed PLC tag binding.

Parameter tagName: The tag Name.
Parameter address: The address.

`P:IoT.Driver.OmronPlcRx.Tags.PlcTag`1.Address`

public string Address { get; }

Gets the address.

Value: The address.

`P:IoT.Driver.OmronPlcRx.Tags.PlcTag`1.TagName`

public string TagName { get; }

Gets the Tag Name.

Value: The name.

`P:IoT.Driver.OmronPlcRx.Tags.PlcTag`1.TagType`

public System.Type TagType { get; }

Gets a value indicating whether this instance is bit address.

Value: true if this instance is bit address; otherwise, false .

`P:IoT.Driver.OmronPlcRx.Tags.PlcTag`1.Value`

public T Value { get; }

Gets the tag value.

Value: The value.

`T:IoT.Driver.OmronPlcRx.ToolbusFinsFrameCodec`

public class IoT.Driver.OmronPlcRx.ToolbusFinsFrameCodec

Encodes and decodes Omron Toolbus serial frames carrying binary FINS messages.

Declared public members

`M:IoT.Driver.OmronPlcRx.ToolbusFinsFrameCodec.CalculateChecksum(System.ReadOnlySpan`1{System.Byte})`

public static ushort CalculateChecksum(System.ReadOnlySpan<byte> data)

Executes the CalculateChecksum operation.

Parameter data: The data value.
Returns: A ushort result.

`M:IoT.Driver.OmronPlcRx.ToolbusFinsFrameCodec.DecodeResponse(System.ReadOnlyMemory`1{System.Byte})`

public static System.Memory<byte> DecodeResponse(System.ReadOnlyMemory<byte> frame)

Executes the DecodeResponse operation.

Parameter frame: The frame value.
Returns: A System.Memory<byte> result.

`M:IoT.Driver.OmronPlcRx.ToolbusFinsFrameCodec.EncodeRequest(System.ReadOnlyMemory`1{System.Byte})`

public static System.Memory<byte> EncodeRequest(System.ReadOnlyMemory<byte> finsMessage)

Executes the EncodeRequest operation.

Parameter finsMessage: The finsMessage value.
Returns: A System.Memory<byte> result.

`P:IoT.Driver.OmronPlcRx.ToolbusFinsFrameCodec.SynchronizationFrame`

public System.ReadOnlyMemory<byte> SynchronizationFrame { get; }

Gets the synchronization frame value.

Value: The SynchronizationFrame value.

Product	Compatible and additional computed target framework versions.
.NET	net8.0 is compatible. net8.0-android was computed. net8.0-browser was computed. net8.0-ios was computed. net8.0-maccatalyst was computed. net8.0-macos was computed. net8.0-tvos was computed. net8.0-windows was computed. net9.0 is compatible. net9.0-android was computed. net9.0-browser was computed. net9.0-ios was computed. net9.0-maccatalyst was computed. net9.0-macos was computed. net9.0-tvos was computed. net9.0-windows was computed. net10.0 is compatible. net10.0-android was computed. net10.0-browser was computed. net10.0-ios was computed. net10.0-maccatalyst was computed. net10.0-macos was computed. net10.0-tvos was computed. net10.0-windows was computed. net11.0 is compatible.
.NET Framework	net462 is compatible. net463 was computed. net47 was computed. net471 was computed. net472 is compatible. net48 was computed. net481 is compatible.

Product

.NET

.NET Framework

Compatible target framework(s)

Included target framework(s) (in package)

Learn more about Target Frameworks and .NET Standard.

.NETFramework 4.6.2
- IoT-Driver.Core (>= 1.0.2)
- IoT-Driver.SerialPortRx.Reactive (>= 1.0.2)
- ReactiveUI.Primitives.Async.Reactive (>= 7.1.0)
- ReactiveUI.Primitives.Reactive (>= 7.1.0)
.NETFramework 4.7.2
- IoT-Driver.Core (>= 1.0.2)
- IoT-Driver.SerialPortRx.Reactive (>= 1.0.2)
- ReactiveUI.Primitives.Async.Reactive (>= 7.1.0)
- ReactiveUI.Primitives.Reactive (>= 7.1.0)
.NETFramework 4.8.1
- IoT-Driver.Core (>= 1.0.2)
- IoT-Driver.SerialPortRx.Reactive (>= 1.0.2)
- ReactiveUI.Primitives.Async.Reactive (>= 7.1.0)
- ReactiveUI.Primitives.Reactive (>= 7.1.0)
net10.0
- IoT-Driver.Core (>= 1.0.2)
- IoT-Driver.SerialPortRx.Reactive (>= 1.0.2)
- ReactiveUI.Primitives.Async.Reactive (>= 7.1.0)
- ReactiveUI.Primitives.Reactive (>= 7.1.0)
net11.0
- IoT-Driver.Core (>= 1.0.2)
- IoT-Driver.SerialPortRx.Reactive (>= 1.0.2)
- ReactiveUI.Primitives.Async.Reactive (>= 7.1.0)
- ReactiveUI.Primitives.Reactive (>= 7.1.0)
net8.0
- IoT-Driver.Core (>= 1.0.2)
- IoT-Driver.SerialPortRx.Reactive (>= 1.0.2)
- ReactiveUI.Primitives.Async.Reactive (>= 7.1.0)
- ReactiveUI.Primitives.Reactive (>= 7.1.0)
net9.0
- IoT-Driver.Core (>= 1.0.2)
- IoT-Driver.SerialPortRx.Reactive (>= 1.0.2)
- ReactiveUI.Primitives.Async.Reactive (>= 7.1.0)
- ReactiveUI.Primitives.Reactive (>= 7.1.0)

NuGet packages (1)

Showing the top 1 NuGet packages that depend on IoT-Driver.OmronPlcRx.Reactive:

Package	Downloads
MQTTnet.Rx.OmronPlc.Reactive ReactiveUI.Primitives extensions for MQTTnet clients, brokers, and industrial device bridges	37

GitHub repositories

This package is not used by any popular GitHub repositories.

Version	Downloads	Last Updated
1.0.2	29	8/3/2026
1.0.1	59	8/1/2026
1.0.0	37	7/31/2026

Omron logical-tag support with FINS, Host Link, Toolbus, Ethernet, serial, and bulk memory-area operations.