IoTClient

https://github.com/zhaopeiym/iotclient
Admin
IoTClient is a cross-platform .NET Standard 2.0 client library for IoT device communication that...
Tokens:13,766
Snippets:45
Trust Score:8.1
License:MIT
Update:9 months ago
Show doc for...
Tokens:
Raw
### Install IoTClient NuGet Package

Source: https://context7.com/zhaopeiym/iotclient/llms.txt

Instructions for installing the IoTClient NuGet package using the Package Manager Console or the .NET CLI.

```bash
# Install via Package Manager Console
Install-Package IoTClient

# Or via .NET CLI
dotnet add package IoTClient
```

--------------------------------

### Siemens PLC Address Formatting and Data Types (C#)

Source: https://github.com/zhaopeiym/iotclient/blob/master/README.md

Explains the Siemens PLC address format, including byte (B), word (W), and doubleword (D) specifiers, and how to map C# data types to Siemens addresses using the client library. It provides examples for various data types and addressing schemes.

```csharp
VB263、VW263、VD263中的B、W、D分别表示：byte型(8位)、word型(16位)、doubleword型(32位)。

When this component passes in the address, there is no need to carry the data type, just use the corresponding method to read the corresponding type, such as:
VB263       - client.ReadByte("V263")
VD263       - client.ReadFloat("V263")
VD263       - client.ReadInt32("V263")
DB108.DBW4  - client.ReadUInt16("DB108.4")
DB1.DBX0.0  - client.ReadBoolean("DB1.0.0")
DB1.DBD0    - client.ReadFloat("DB1.0")
```

--------------------------------

### Mitsubishi MC Protocol Communication Client

Source: https://context7.com/zhaopeiym/iotclient/llms.txt

Facilitates communication with Mitsubishi PLCs utilizing the MC Protocol, supporting both A-1E and Qna-3E frames. It allows access to various device types including M relays, D registers, X inputs, Y outputs, W link registers, and special registers. Examples include reading and writing different data types and handling the results.

```csharp
using IoTClient.Clients.PLC;
using IoTClient.Enums;

// Initialize for Q-series or iQ-R (Qna_3E frame)
var client = new MitsubishiClient(MitsubishiVersion.Qna_3E, "192.168.1.10", 6000);

// Or for A-series (A_1E frame)
var clientA = new MitsubishiClient(MitsubishiVersion.A_1E, "192.168.1.11", 5000);

client.Open();

// Write to data registers (D)
client.Write("D0", (short)100);
client.Write("D2", (int)123456);
client.Write("D6", (float)3.14f);
client.Write("D10", (double)6.283185);

// Write to M relays (bit devices)
client.Write("M0", true);
client.Write("M100", false);

// Read data registers
var d0 = client.ReadInt16("D0");
var d2 = client.ReadInt32("D2");
var d6 = client.ReadFloat("D6");
var d10 = client.ReadDouble("D10");

// Read M relays
var m0 = client.ReadBoolean("M0");
var m100 = client.ReadBoolean("M100");

// Read input/output relays
var x0 = client.ReadBoolean("X0");    // Input X0
var y0 = client.ReadBoolean("Y0");    // Output Y0

// Read link registers
var w0 = client.ReadInt16("W0");

// Result handling
if (d0.IsSucceed)
{
    Console.WriteLine($"D0 = {d0.Value}");
    Console.WriteLine($"Request: {d0.Requst}");
    Console.WriteLine($"Response: {d0.Response}");
}
else
{
    Console.WriteLine($"Read failed: {d0.Err}");
}

client.Close();
```

--------------------------------

### Result<T> Operation Result Handling and Error Reporting (C#)

Source: https://context7.com/zhaopeiym/iotclient/llms.txt

Explains the Result<T> class used for all IoTClient read/write operations, detailing its properties for value, success status, error messages, error codes, exceptions, and raw packet data. Provides an example of comprehensive error handling with a ModBusTcpClient.

```csharp
using IoTClient;

// Result class structure
public class Result<T> : Result
{
    public T Value { get; set; }           // The returned value
    public bool IsSucceed { get; set; }    // Operation success flag
    public string Err { get; set; }        // Error message if failed
    public int ErrCode { get; set; }       // Error code (408 = connection failed)
    public Exception Exception { get; set; } // Full exception details
    public string Requst { get; set; }     // Raw request packet (hex)
    public string Response { get; set; }   // Raw response packet (hex)
    public double? TimeConsuming { get; set; } // Operation time in ms
    public List<string> ErrList { get; set; } // Accumulated errors
}

// Comprehensive error handling example
var client = new ModBusTcpClient("192.168.1.100", 502);
client.Open();

var result = client.ReadFloat("100", stationNumber: 1, functionCode: 3);

if (result.IsSucceed)
{
    Console.WriteLine($"Value: {result.Value}");
    Console.WriteLine($"Time: {result.TimeConsuming}ms");

    // Debug protocol communication
    Console.WriteLine($"Request bytes: {result.Requst}");
    Console.WriteLine($"Response bytes: {result.Response}");
}
else
{
    Console.WriteLine($"Error: {result.Err}");
    Console.WriteLine($"Error Code: {result.ErrCode}");

    if (result.ErrCode == 408)
    {
        Console.WriteLine("Connection failed - check network");
    }

    // Log all accumulated errors
    foreach (var err in result.ErrList)
    {
        Console.WriteLine($"  - {err}");
    }

    // Access full exception for stack trace
    if (result.Exception != null)
    {
        Console.WriteLine($"Exception: {result.Exception}");
    }
}

client.Close();
```

--------------------------------

### MitsubishiClient: Instantiate, Read, and Write Operations (C#)

Source: https://github.com/zhaopeiym/iotclient/blob/master/README.md

Illustrates how to instantiate a MitsubishiClient for the Qna_3E version, perform single read and write operations, and access the results. It also emphasizes the recommendation for manual connection management.

```csharp
//1、Instantiate the client-enter the correct IP and port
MitsubishiClient client = new MitsubishiClient(MitsubishiVersion.Qna_3E, "127.0.0.1",6000);

//2、Write operation
client.Write("M100", true);
client.Write("D200", (short)11);
client.Write("D210", 33);

//3、Read operation
var value1 = client.ReadBoolean("M100").Value;
var value2 = client.ReadInt16("D200").Value;
var value3 = client.ReadInt32("D210").Value;

//4、If there is no active Open, it will automatically open and close the connection every time you read and write operations, which will greatly reduce the efficiency of reading and writing. So it is recommended to open and close manually.
client.Open();

//5、Read and write operations will return the operation result object Result
var result = client.ReadInt16("D210");
//5.1 Whether the reading is successful (true or false)
var isSucceed = result.IsSucceed;
//5.2 Exception information for failed reading
var errMsg = result.Err;
//5.3 Read the request message actually sent by the operation
var requst  = result.Requst;
//5.4 Read the response message from the server
var response = result.Response;
//5.5 Read value
var value4 = result.Value;
```

--------------------------------

### Omron FINS Protocol Client Initialization and Operations (C#)

Source: https://context7.com/zhaopeiym/iotclient/llms.txt

Demonstrates initializing an OmronFinsClient, configuring node addresses, opening the connection, and performing read/write operations on various memory areas (DM, CIO, WR, HR, AR). Includes batch reading and handling different data types.

```csharp
using IoTClient.Clients.PLC;
using IoTClient.Enums;

// Initialize FINS client (default port 9600)
var client = new OmronFinsClient("192.168.1.20", 9600, timeout: 1500, endianFormat: EndianFormat.CDAB);

// Configure node addresses if needed
client.SA1 = 0x0B;          // Client node address
client.UnitAddress = 0x00;  // Target unit (0x00 = CPU)

client.Open();

// Write to DM area (Data Memory)
client.Write("D0", (short)100);
client.Write("D2", (int)123456);
client.Write("D6", (float)3.14f);
client.Write("D10", (double)6.283);
client.Write("D100.0", true);         // Write bit D100.0

// Read from DM area
var d0 = client.ReadInt16("D0");
var d2 = client.ReadInt32("D2");
var d6 = client.ReadFloat("D6");
var d10 = client.ReadDouble("D10");
var bit = client.ReadBoolean("D100.0");

// CIO area (I/O memory)
client.Write("C0", (short)50);
var cio = client.ReadInt16("C0");

// WR area (Work relay)
client.Write("W0", (short)200);
var wr = client.ReadInt16("W0");

// HR area (Holding relay)
client.Write("H0", (short)300);
var hr = client.ReadInt16("H0");

// AR area (Auxiliary relay)
var ar = client.ReadInt16("A0");

// Batch read multiple addresses
var addresses = new Dictionary<string, DataTypeEnum>
{
    { "D0", DataTypeEnum.Int16 },
    { "D2", DataTypeEnum.Int32 },
    { "D6", DataTypeEnum.Float },
    { "D10", DataTypeEnum.Double }
};
var batch = client.BatchRead(addresses, batchNumber: 121);
foreach (var kv in batch.Value)
{
    Console.WriteLine($"{kv.Key}: {kv.Value}");
}

client.Close();
```

--------------------------------

### SiemensClient: Instantiate, Read, and Write Operations (C#)

Source: https://github.com/zhaopeiym/iotclient/blob/master/README.md

Demonstrates how to instantiate a SiemensClient for different PLC versions, perform single read and write operations, and handle results. It also highlights the importance of manual connection management for performance.

```csharp
//1、Instantiate the client-enter the model, IP and port
//Other models：SiemensVersion.S7_200、SiemensVersion.S7_300、SiemensVersion.S7_400、SiemensVersion.S7_1200、SiemensVersion.S7_1500
SiemensClient client = new SiemensClient(SiemensVersion.S7_200Smart, "127.0.0.1",102);

//2、Write operation
client.Write("Q1.3", true);
client.Write("V2205", (short)11);
client.Write("V2209", 33);

//3、Read operation
var value1 = client.ReadBoolean("Q1.3").Value;
var value2 = client.ReadInt16("V2205").Value;
var value3 = client.ReadInt32("V2209").Value;

//4、If there is no active Open, it will automatically open and close the connection every time you read and write operations, which will greatly reduce the efficiency of reading and writing. So it is recommended to open and close manually.
client.Open();

//5、Read and write operations will return the operation result object Result
var result = client.ReadInt16("V2205");
//5.1 Whether the reading is successful (true or false)
var isSucceed = result.IsSucceed;
//5.2 Exception information for failed reading
var errMsg = result.Err;
//5.3 Read the request message actually sent by the operation
var requst  = result.Requst;
//5.4 Read the response message from the server
var response = result.Response;
//5.5 Read value
var value4 = result.Value;
```

--------------------------------

### SiemensClient Best Practices: Connection and Batch Operations (C#)

Source: https://github.com/zhaopeiym/iotclient/blob/master/README.md

Outlines best practices for using the SiemensClient, including when to manually open connections for performance gains and how to leverage batch read/write operations. It also emphasizes clarifying data types during writes and notes that the class is thread-safe.

```csharp
//1、When not to take the initiative to open
//Siemens plc generally allows up to 8 long connections. So when the number of connections is not enough or when doing testing, do not take the initiative to open, so that the component will automatically open and close immediately.

//2、When to take the initiative to open
//When the number of long connections is enough, and you want to improve the read and write performance.

//3、In addition to active Open connections, batch read and write can also greatly improve read and write performance.
//Batch read
Dictionary<string, DataTypeEnum> addresses = new Dictionary<string, DataTypeEnum>();
addresses.Add("DB4.24", DataTypeEnum.Float);
addresses.Add("DB1.434.0", DataTypeEnum.Bool);
addresses.Add("V4109", DataTypeEnum.Byte);
...
var result = client.BatchRead(addresses);

//Batch write
Dictionary<string, object> addresses = new Dictionary<string, object>();
addresses.Add("DB4.24", (float)1);
addresses.Add("DB4.0", (float)2);
addresses.Add("DB1.434.0", true);
...
var result = client.BatchWrite(addresses);

//4、[Note] When writing data, you need to clarify the data type
client.Write("DB4.12", 9);          //What is written is of type int
client.Write("DB4.12", (float)9);   //What is written is a float type

//5、SiemensClient is a thread safe class
//Due to limited long PLC connections, SiemensClient is designed as a thread-safe class. You can set SiemensClient as a singleton, and use the instance of SiemensClient to read and write PLC between multiple threads.
```

--------------------------------

### Allen Bradley EtherNet/IP Client Initialization and Tag Operations (C#)

Source: https://context7.com/zhaopeiym/iotclient/llms.txt

Illustrates initializing an AllenBradleyClient for EtherNet/IP communication, opening the connection, and performing read/write operations using tag-based addressing. Shows how to handle different data types, read array elements, and access session information.

```csharp
using IoTClient.Clients.PLC;
using IoTClient.Enums;

// Initialize Allen Bradley client (default port 44818)
var client = new AllenBradleyClient("192.168.1.30", 44818, slot: 0, timeout: 1500);

client.Open();

// Write to tags (use tag names as addresses)
client.Write("MyIntTag", (short)100);
client.Write("MyDintTag", (int)123456);
client.Write("MyRealTag", (float)3.14f);
client.Write("MyLrealTag", (double)6.283);
client.Write("MyBoolTag", true);

// Read from tags
var intTag = client.ReadInt16("MyIntTag");
var dintTag = client.ReadInt32("MyDintTag");
var realTag = client.ReadFloat("MyRealTag");
var lrealTag = client.ReadDouble("MyLrealTag");
var boolTag = client.ReadBoolean("MyBoolTag");

// Read array elements
var arrayElement = client.ReadInt32("MyArray[5]");

// Result handling with session info
Console.WriteLine($"Session Handle: {client.Session}");
if (intTag.IsSucceed)
{
    Console.WriteLine($"Tag value: {intTag.Value}");
}

client.Close();
```

--------------------------------

### OmronFinsClient Read/Write Operations

Source: https://github.com/zhaopeiym/iotclient/blob/master/README.md

Demonstrates how to instantiate, write to, and read from an Omron PLC using the OmronFinsClient. It highlights manual connection management for performance and explains the structure of the operation result object, including success status, error messages, and data values. Dependencies include the OmronFinsClient class.

```csharp
OmronFinsClient client = new OmronFinsClient("127.0.0.1",6000);

// Write operation
client.Write("M100", true);
client.Write("D200", (short)11);
client.Write("D210", 33);

// Read operation
var value1 = client.ReadBoolean("M100").Value;
var value2 = client.ReadInt16("D200").Value;
var value3 = client.ReadInt32("D210").Value;

// Manual connection management recommended for efficiency
client.Open();

// Read/write operations return a Result object
var result = client.ReadInt16("D210");
var isSucceed = result.IsSucceed;
var errMsg = result.Err;
var requst  = result.Requst;
var response = result.Response;
var value4 = result.Value;
```

--------------------------------

### Manual Connection Management with Siemens PLC Client (C#)

Source: https://context7.com/zhaopeiym/iotclient/llms.txt

Demonstrates manual connection management using SiemensClient for continuous operations. It shows opening the connection once, performing multiple read operations within a try-finally block, and closing the connection. This approach offers better performance for sustained communication.

```csharp
using IoTClient.Clients.PLC;

// RECOMMENDED: Manual connection management for continuous operations
var client = new SiemensClient(SiemensVersion.S7_1200, "192.168.1.1", 102);

// Open once, perform many operations
client.Open();
try
{
    // All operations share the same connection
    for (int i = 0; i < 1000; i++)
    {
        var result = client.ReadFloat("DB1.0");
        // Process result...
    }
}
finally
{
    client.Close(); // Always close when done
}

// AUTO MODE: Connection opens/closes per operation (slower, but simpler)
// Just don't call Open() - connection managed automatically
var autoClient = new SiemensClient(SiemensVersion.S7_1200, "192.168.1.1", 102);
var value = autoClient.ReadFloat("DB1.0"); // Auto-connects and disconnects

// Check connection status
Console.WriteLine($"Connected: {client.Connected}");

// Thread-safe: SiemensClient is designed for multi-threaded access
// Create singleton instance and share across threads
Task.Run(() => client.ReadFloat("DB1.0"));
Task.Run(() => client.ReadFloat("DB1.4"));
```

--------------------------------

### SiemensClient Best Practices

Source: https://github.com/zhaopeiym/iotclient/blob/master/README.md

Recommendations for optimizing the usage of SiemensClient, including connection management, batch operations, and thread safety.

```APIDOC
## SiemensClient Best Practices

### Description
Guidance on efficient and effective use of the SiemensClient, covering connection strategies, batch processing, and thread safety.

### Method
N/A (Class methods)

### Endpoint
N/A (Local client)

### Parameters
N/A (Class methods)

### Request Example
```csharp
// Batch read
Dictionary<string, DataTypeEnum> addresses = new Dictionary<string, DataTypeEnum>();
addresses.Add("DB4.24", DataTypeEnum.Float);
addresses.Add("DB1.434.0", DataTypeEnum.Bool);
addresses.Add("V4109", DataTypeEnum.Byte);
var batchReadResult = client.BatchRead(addresses);

// Batch write
Dictionary<string, object> writeAddresses = new Dictionary<string, object>();
writeAddresses.Add("DB4.24", (float)1);
writeAddresses.Add("DB4.0", (float)2);
writeAddresses.Add("DB1.434.0", true);
var batchWriteResult = client.BatchWrite(writeAddresses);

// Specify data type for writing
client.Write("DB4.12", 9);          // Writes as int
client.Write("DB4.12", (float)9);   // Writes as float
```

### Response
- **Batch Read/Write Result**: Returns a collection of results, typically a dictionary mapping addresses to their operation status and values.

### Best Practices
1.  **When NOT to proactively open**: If connection count is limited or for testing, do not call `client.Open()`. The component will automatically open and close connections for each operation.
2.  **When to proactively open**: If the number of long connections is sufficient and you need to improve read/write performance, call `client.Open()`.
3.  **Batch Read/Write**: Significantly improves performance. Use `BatchRead` and `BatchWrite` methods with dictionaries specifying addresses and data types/values.
4.  **Clarify Data Type for Writing**: Ensure the correct data type is provided when writing to avoid unexpected behavior.
5.  **Thread Safety**: `SiemensClient` is thread-safe. It can be used as a singleton across multiple threads to manage PLC connections efficiently.
```

--------------------------------

### AllenBradleyClient Read/Write Operations

Source: https://github.com/zhaopeiym/iotclient/blob/master/README.md

Illustrates how to use the AllenBradleyClient for read and write operations with Allen Bradley PLCs. This includes client instantiation, writing data, reading data, and managing the connection manually for improved efficiency. It also details how to interpret the Result object returned by read/write operations. Dependencies include the AllenBradleyClient class.

```csharp
AllenBradleyClient client = new AllenBradleyClient("127.0.0.1",44818);

// Write operation 
client.Write("A1", (short)11); 

// Read operation
var value = client.ReadInt16("A1").Value;

// Manual connection management recommended for efficiency
client.Open();

// Read/write operations return a Result object
var result = client.ReadInt16("A1");
var isSucceed = result.IsSucceed;
var errMsg = result.Err;
var requst  = result.Requst;
var response = result.Response;
var value4 = result.Value;
```

--------------------------------

### SiemensClient Read and Write Operations

Source: https://github.com/zhaopeiym/iotclient/blob/master/README.md

This section covers the instantiation, basic read/write operations, and handling of results for the SiemensClient.

```APIDOC
## SiemensClient (Siemens) Read and Write Operations

### Description
Provides methods for reading from and writing to Siemens PLCs. Supports various Siemens PLC models and data types.

### Method
N/A (Class methods)

### Endpoint
N/A (Local client)

### Parameters
N/A (Class methods)

### Request Example
```csharp
// Instantiate the client - enter the model, IP and port
// Other models: SiemensVersion.S7_200, SiemensVersion.S7_300, SiemensVersion.S7_400, SiemensVersion.S7_1200, SiemensVersion.S7_1500
SiemensClient client = new SiemensClient(SiemensVersion.S7_200Smart, "127.0.0.1", 102);

// Write operation
client.Write("Q1.3", true);
client.Write("V2205", (short)11);
client.Write("V2209", 33);

// Read operation
var value1 = client.ReadBoolean("Q1.3").Value;
var value2 = client.ReadInt16("V2205").Value;
var value3 = client.ReadInt32("V2209").Value;

// Open and close connection manually for better performance
client.Open();

// Read/write operations return a Result object
var result = client.ReadInt16("V2205");
var isSucceed = result.IsSucceed;
var errMsg = result.Err;
var requst  = result.Requst;
var response = result.Response;
var value4 = result.Value;
```

### Response
#### Success Response (Operation Result Object)
- **IsSucceed** (bool) - Indicates if the operation was successful.
- **Err** (string) - Error message if the operation failed.
- **Requst** (object) - The actual request message sent.
- **Response** (object) - The response message from the server.
- **Value** (object) - The data read from the PLC (type depends on the read method).

#### Response Example
```json
{
  "IsSucceed": true,
  "Err": null,
  "Requst": { ... },
  "Response": { ... },
  "Value": 11
}
```

### Note: About Siemens PLC Address
VB263, VW263, VD263 where B, W, D represent: byte (8-bit), word (16-bit), double word (32-bit).

When passing the address, the data type is not required, just use the corresponding method to read the corresponding type, e.g.:
VB263 - `client.ReadByte("V263")`
VD263 - `client.ReadFloat("V263")`
VD263 - `client.ReadInt32("V263")`
DB108.DBW4 - `client.ReadUInt16("DB108.4")`
DB1.DBX0.0 - `client.ReadBoolean("DB1.0.0")`
DB1.DBD0 - `client.ReadFloat("DB1.0")`

| C# data type | smart200 | 1200/1500/300 |
|---|---|---|
| bit | V1.0 | DB1.DBX1.0 |
| byte | VB1 | DB1.DBB1 |
| short <br> ushort | VW2 | DB1.DBW2 |
| int <br> uint <br> float | VD4 | DB1.DBD4 |
```

--------------------------------

### Modbus RTU Client - IoTClient.Clients.Modbus.ModBusRtuClient

Source: https://context7.com/zhaopeiym/iotclient/llms.txt

This section covers the ModBusRtuClient for serial communication using the Modbus RTU protocol. It explains how to initialize the client with serial port configurations and demonstrates read/write operations, highlighting that the API is consistent with the ModBusTcpClient.

```APIDOC
## Modbus RTU Client - IoTClient.Clients.Modbus.ModBusRtuClient

### Description
Communicates with Modbus RTU devices over serial ports. It shares the same read/write API as ModBusTcpClient but uses serial port configuration for communication.

### Method
- **Initialization**: `new ModBusRtuClient(string portName, int baudRate, int dataBits, StopBits stopBits, Parity parity)`
- **Connection**: `client.Open()` and `client.Close()`

### Write Operations
- `client.Write(string address, T value, int stationNumber, int functionCode)`: Supports writing various data types, consistent with ModBusTcpClient.
  - Example: `client.Write("0", (short)500, stationNumber: 1, functionCode: 16);`

### Read Operations
- `client.ReadInt16(string address, int stationNumber, int functionCode)`
- Other read operations are available and consistent with ModBusTcpClient.
  - All read operations return a `Result<T>` object.

### Result Object (`Result<T>`)
- `IsSucceed` (bool): Indicates if the operation was successful.
- `Value` (T): The returned value of the operation.
- `Err` (string): Error message if the operation failed.

### Request Example
```csharp
using System.IO.Ports;

var client = new ModBusRtuClient(
    portName: "COM3",
    baudRate: 9600,
    dataBits: 8,
    stopBits: StopBits.One,
    parity: Parity.None
);

client.Open();
var result = client.ReadInt16("0", stationNumber: 1, functionCode: 3);
if (result.IsSucceed)
{
    Console.WriteLine($"Register value: {result.Value}");
}
client.Close();
```

### Response Example
```json
{
  "IsSucceed": true,
  "Value": 500,
  "Err": null
}
```
```

--------------------------------

### Modbus TCP Communication with ModBusTcpClient

Source: https://context7.com/zhaopeiym/iotclient/llms.txt

Demonstrates how to use the ModBusTcpClient to connect to Modbus TCP devices, perform read/write operations for various data types, and handle batch operations. It also shows how to check the success and details of each operation.

```csharp
using IoTClient.Clients.Modbus;
using IoTClient.Enums;
using IoTClient.Models;

// Initialize client with IP, port, timeout (ms), and endian format
var client = new ModBusTcpClient("192.168.1.100", 502, 1500, EndianFormat.ABCD);

// Open connection for better performance (recommended)
client.Open();

// Write operations - specify address, value, station number, function code
client.Write("0", (short)100, 1, 16);      // Write short to address 0
client.Write("2", (ushort)200, 1, 16);     // Write ushort to address 2
client.Write("4", (int)12345, 1, 16);      // Write int to address 4
client.Write("8", (float)3.14f, 1, 16);    // Write float to address 8
client.Write("12", (double)6.28, 1, 16);   // Write double to address 12
client.Write("100", true, 1, 5);           // Write coil (function code 5)
client.Write("200", "Hello", 1, 16);       // Write string

// Read operations - returns Result<T> with value and status
var shortResult = client.ReadInt16("0", 1, 3);
var ushortResult = client.ReadUInt16("2", 1, 3);
var intResult = client.ReadInt32("4", 1, 3);
var floatResult = client.ReadFloat("8", 1, 3);
var doubleResult = client.ReadDouble("12", 1, 3);
var coilResult = client.ReadCoil("100", 1, 1);
var discreteResult = client.ReadDiscrete("50", 1, 2);
var stringResult = client.ReadString("200", 1, 3, readLength: 10);

// Check result status
if (shortResult.IsSucceed)
{
    Console.WriteLine($"Value: {shortResult.Value}");
    Console.WriteLine($"Request: {shortResult.Requst}");
    Console.WriteLine($"Response: {shortResult.Response}");
    Console.WriteLine($"Time: {shortResult.TimeConsuming}ms");
}
else
{
    Console.WriteLine($"Error: {shortResult.Err}");
}

// Batch read multiple addresses with different data types
var batchAddresses = new List<ModBusInput>
{
    new ModBusInput { Address = "0", DataType = DataTypeEnum.Int16, FunctionCode = 3, StationNumber = 1 },
    new ModBusInput { Address = "2", DataType = DataTypeEnum.Float, FunctionCode = 3, StationNumber = 1 },
    new ModBusInput { Address = "6", DataType = DataTypeEnum.Int32, FunctionCode = 3, StationNumber = 1 }
};
var batchResult = client.BatchRead(batchAddresses, retryCount: 2);
foreach (var item in batchResult.Value)
{
    Console.WriteLine($"Address {item.Address}: {item.Value}");
}

// Close connection when done
client.Close();
```

--------------------------------

### Siemens S7 PLC Communication Client

Source: https://context7.com/zhaopeiym/iotclient/llms.txt

Enables communication with a range of Siemens PLCs using the S7 protocol. It supports S7-200, S7-200Smart, S7-300, S7-400, S7-1200, and S7-1500, providing access to all data areas (I, Q, M, DB, V, T, C) with type-safe addressing. Batch read/write operations are supported for performance.

```csharp
using IoTClient.Clients.PLC;
using IoTClient.Enums;

// Initialize for S7-200Smart (default port 102)
var client = new SiemensClient(SiemensVersion.S7_200Smart, "192.168.1.1", 102);

// For S7-1200/1500, specify slot and rack if needed
var client1200 = new SiemensClient(SiemensVersion.S7_1200, "192.168.1.2", 102, slot: 0, rack: 0);

client.Open();

// Write to V area (S7-200Smart)
client.Write("V100", (short)1234);           // Write short to V100
client.Write("V102", (int)567890);           // Write int to V102
client.Write("V106", (float)3.14159f);       // Write float to V106
client.Write("V110", true);                  // Write bool to V110.0
client.Write("V1.3", true);                  // Write specific bit V1.3

// Read from V area
var shortVal = client.ReadInt16("V100");
var intVal = client.ReadInt32("V102");
var floatVal = client.ReadFloat("V106");
var boolVal = client.ReadBoolean("V110.0");

// DB block access (S7-300/400/1200/1500)
// Format: DB{number}.{offset} or DB{number}.DBX{offset}.{bit}
client.Write("DB1.0", (float)25.5f);         // Write float to DB1, offset 0
client.Write("DB1.4", (int)100);             // Write int to DB1, offset 4
client.Write("DB1.DBX8.0", true);            // Write bit to DB1, byte 8, bit 0

var dbFloat = client.ReadFloat("DB1.0");
var dbInt = client.ReadInt32("DB1.4");
var dbBool = client.ReadBoolean("DB1.8.0");  // Alternative format

// M (marker), I (input), Q (output) areas
client.Write("M0", (byte)255);
client.Write("M100.0", true);
var marker = client.ReadBoolean("M100.0");
var input = client.ReadBoolean("I0.0");
var output = client.ReadBoolean("Q0.0");

// Batch read for improved performance
var addresses = new Dictionary<string, DataTypeEnum>
{
    { "V100", DataTypeEnum.Int16 },
    { "V102", DataTypeEnum.Int32 },
    { "V106", DataTypeEnum.Float },
    { "DB1.0", DataTypeEnum.Float },
    { "DB1.4.0", DataTypeEnum.Bool }
};
var batchResult = client.BatchRead(addresses, batchNumber: 19);
foreach (var kv in batchResult.Value)
{
    Console.WriteLine($"{kv.Key}: {kv.Value}");
}

// Batch write multiple addresses
var writeAddresses = new Dictionary<string, object>
{
    { "V100", (short)100 },
    { "V102", (int)200 },
    { "V106", (float)3.14f },
    { "DB1.0", (float)25.0f }
};
var batchWriteResult = client.BatchWrite(writeAddresses, batchNumber: 10);

// Read string from PLC
var stringResult = client.ReadString("V200");

client.Close();
```

--------------------------------

### Modbus RTU Serial Communication with ModBusRtuClient

Source: https://context7.com/zhaopeiym/iotclient/llms.txt

Illustrates how to establish communication with Modbus RTU devices using the ModBusRtuClient over a serial port. It mirrors the ModBusTcpClient API for read/write operations but requires specific serial port configurations.

```csharp
using IoTClient.Clients.Modbus;
using System.IO.Ports;

// Initialize with serial port settings
var client = new ModBusRtuClient(
    portName: "COM3",
    baudRate: 9600,
    dataBits: 8,
    stopBits: StopBits.One,
    parity: Parity.None
);

client.Open();

// Read holding register (same API as TCP client)
var result = client.ReadInt16("0", stationNumber: 1, functionCode: 3);
if (result.IsSucceed)
{
    Console.WriteLine($"Register value: {result.Value}");
}

// Write to holding register
var writeResult = client.Write("0", (short)500, stationNumber: 1, functionCode: 16);
Console.WriteLine($"Write success: {writeResult.IsSucceed}");

client.Close();
```

--------------------------------

### Modbus TCP Client - IoTClient.Clients.Modbus.ModBusTcpClient

Source: https://context7.com/zhaopeiym/iotclient/llms.txt

This section details the usage of the ModBusTcpClient for communicating with Modbus TCP devices. It covers initialization, connection management, writing data to various data types (short, ushort, int, float, double, coil, string), reading data, and performing batch operations. Error handling and result interpretation are also explained.

```APIDOC
## Modbus TCP Client - IoTClient.Clients.Modbus.ModBusTcpClient

### Description
Provides communication with Modbus TCP devices, supporting standard function codes for reading/writing coils, discrete inputs, holding registers, and input registers. It handles endianness conversion and supports batch operations.

### Method
- **Initialization**: `new ModBusTcpClient(string ip, int port, int timeout, EndianFormat endianFormat)`
- **Connection**: `client.Open()` and `client.Close()`

### Write Operations
- `client.Write(string address, T value, int stationNumber, int functionCode)`: Supports writing various data types.
  - Example: `client.Write("0", (short)100, 1, 16);`
  - Example: `client.Write("100", true, 1, 5);`
  - Example: `client.Write("200", "Hello", 1, 16);`

### Read Operations
- `client.ReadInt16(string address, int stationNumber, int functionCode)`
- `client.ReadUInt16(string address, int stationNumber, int functionCode)`
- `client.ReadInt32(string address, int stationNumber, int functionCode)`
- `client.ReadFloat(string address, int stationNumber, int functionCode)`
- `client.ReadDouble(string address, int stationNumber, int functionCode)`
- `client.ReadCoil(string address, int stationNumber, int functionCode)`
- `client.ReadDiscrete(string address, int stationNumber, int functionCode)`
- `client.ReadString(string address, int stationNumber, int functionCode, int readLength)`
  - All read operations return a `Result<T>` object.

### Batch Operations
- `client.BatchRead(List<ModBusInput> addresses, int retryCount)`
  - `ModBusInput` contains `Address`, `DataTypeEnum`, `FunctionCode`, and `StationNumber`.

### Result Object (`Result<T>`)
- `IsSucceed` (bool): Indicates if the operation was successful.
- `Value` (T): The returned value of the operation.
- `Err` (string): Error message if the operation failed.
- `Requst` (string): Raw request data.
- `Response` (string): Raw response data.
- `TimeConsuming` (long): Time taken for the operation in milliseconds.

### Request Example
```csharp
var client = new ModBusTcpClient("192.168.1.100", 502, 1500, EndianFormat.ABCD);
client.Open();
var shortResult = client.ReadInt16("0", 1, 3);
if (shortResult.IsSucceed)
{
    Console.WriteLine($"Value: {shortResult.Value}");
}
client.Close();
```

### Response Example
```json
{
  "IsSucceed": true,
  "Value": 100,
  "Err": null,
  "Requst": "...",
  "Response": "...",
  "TimeConsuming": 50
}
```
```

--------------------------------

### MitsubishiClient Read and Write Operations

Source: https://github.com/zhaopeiym/iotclient/blob/master/README.md

Details on using the MitsubishiClient for reading and writing data to Mitsubishi PLCs, including instantiation and result handling.

```APIDOC
## MitsubishiClient (Mitsubishi) Read and Write Operations

### Description
Provides methods for reading from and writing to Mitsubishi PLCs. Supports various Mitsubishi PLC models and data types.

### Method
N/A (Class methods)

### Endpoint
N/A (Local client)

### Parameters
N/A (Class methods)

### Request Example
```csharp
// Instantiate the client - enter the correct IP and port
MitsubishiClient client = new MitsubishiClient(MitsubishiVersion.Qna_3E, "127.0.0.1", 6000);

// Write operation
client.Write("M100", true);
client.Write("D200", (short)11);
client.Write("D210", 33);

// Read operation
var value1 = client.ReadBoolean("M100").Value;
var value2 = client.ReadInt16("D200").Value;
var value3 = client.ReadInt32("D210").Value;

// Open and close connection manually for better performance
client.Open();

// Read/write operations return a Result object
var result = client.ReadInt16("D210");
var isSucceed = result.IsSucceed;
var errMsg = result.Err;
var requst  = result.Requst;
var response = result.Response;
var value4 = result.Value;
```

### Response
#### Success Response (Operation Result Object)
- **IsSucceed** (bool) - Indicates if the operation was successful.
- **Err** (string) - Error message if the operation failed.
- **Requst** (object) - The actual request message sent.
- **Response** (object) - The response message from the server.
- **Value** (object) - The data read from the PLC (type depends on the read method).

#### Response Example
```json
{
  "IsSucceed": true,
  "Err": null,
  "Requst": { ... },
  "Response": { ... },
  "Value": 33
}
```
```

--------------------------------

### OmronFinsClient - Omron FINS Protocol

Source: https://context7.com/zhaopeiym/iotclient/llms.txt

Implements the FINS protocol for Omron PLCs. Supports various memory areas (DM, CIO, WR, HR, AR) and configurable endianness. Provides methods for writing and reading different data types, including individual bits and batch operations.

```APIDOC
## OmronFinsClient - Omron FINS Protocol

### Description

Implements the FINS protocol for Omron PLCs, supporting DM, CIO, WR, HR, AR, and extended memory areas with configurable endianness.

### Method

*Initialization*
```csharp
var client = new OmronFinsClient("192.168.1.20", 9600, timeout: 1500, endianFormat: EndianFormat.CDAB);
client.SA1 = 0x0B;
client.UnitAddress = 0x00;
client.Open();
```

*Write Operations*
```csharp
client.Write("D0", (short)100);
client.Write("D2", (int)123456);
client.Write("D6", (float)3.14f);
client.Write("D10", (double)6.283);
client.Write("D100.0", true); // Write bit
```

*Read Operations*
```csharp
var d0 = client.ReadInt16("D0");
var d2 = client.ReadInt32("D2");
var d6 = client.ReadFloat("D6");
var d10 = client.ReadDouble("D10");
var bit = client.ReadBoolean("D100.0");
```

*Other Memory Areas*
```csharp
client.Write("C0", (short)50); // CIO area
var cio = client.ReadInt16("C0");

client.Write("W0", (short)200); // WR area
var wr = client.ReadInt16("W0");

client.Write("H0", (short)300); // HR area
var hr = client.ReadInt16("H0");

var ar = client.ReadInt16("A0"); // AR area
```

*Batch Read*
```csharp
var addresses = new Dictionary<string, DataTypeEnum>
{
    { "D0", DataTypeEnum.Int16 },
    { "D2", DataTypeEnum.Int32 },
    { "D6", DataTypeEnum.Float },
    { "D10", DataTypeEnum.Double }
};
var batch = client.BatchRead(addresses, batchNumber: 121);
foreach (var kv in batch.Value)
{
    Console.WriteLine($"{kv.Key}: {kv.Value}");
}
```

*Close Connection*
```csharp
client.Close();
```

### Parameters

* **ipAddress** (string): The IP address of the Omron PLC.
* **port** (int): The port number for FINS communication (default is 9600).
* **timeout** (int): The communication timeout in milliseconds.
* **endianFormat** (EndianFormat): The endianness format (e.g., EndianFormat.CDAB).
* **SA1** (byte): Client node address (optional).
* **UnitAddress** (byte): Target unit address (optional, default is 0x00 for CPU).

### Request Body

Not applicable for initialization, parameters are passed to the constructor or set as properties.

### Response

*Success Response (return type is Result<T> for read operations)*
- **Value** (T): The read value.
- **IsSucceed** (bool): True if the operation was successful, false otherwise.
- **Err** (string): Error message if the operation failed.
- **ErrCode** (int): Error code.
- **Exception** (Exception): Full exception details if an exception occurred.
- **Requst** (string): Raw request packet in hex format.
- **Response** (string): Raw response packet in hex format.
- **TimeConsuming** (double?): Time taken for the operation in milliseconds.
- **ErrList** (List<string>): List of accumulated errors.

### Request Example

*Writing a short value to D0:*
```csharp
client.Write("D0", (short)100);
```

### Response Example

*Reading an Int16 value from D0:*
```csharp
var d0 = client.ReadInt16("D0");
// Assuming d0.IsSucceed is true, d0.Value will contain the short value.
```
```

--------------------------------

### Modbus RTU over TCP Client

Source: https://context7.com/zhaopeiym/iotclient/llms.txt

Establishes a Modbus RTU communication channel over a TCP connection. This is useful for scenarios involving serial-to-Ethernet converters or transparent data transmission. It supports standard Modbus read/write operations.

```csharp
using IoTClient.Clients.Modbus;
using IoTClient.Enums;

// RTU messages over TCP connection
var client = new ModbusRtuOverTcpClient("192.168.1.100", 502, 1500, EndianFormat.ABCD);

client.Open();

// Same read/write API as other Modbus clients
var result = client.ReadFloat("10", stationNumber: 1, functionCode: 3);
Console.WriteLine($"Temperature: {result.Value}");

client.Write("20", (float)25.5f, stationNumber: 1, functionCode: 16);

client.Close();
```
Tokens:
Raw