## 摘要



压缩与解压是计算机领域中常用的数据处理技术。通过压缩可以减小文件的大小，节省存储空间和传输带宽。而解压则是将压缩文件恢复为原始文件的过程。在C#中，我们可以使用各种库和算法来实现压缩与解压操作。

## 正文



### GZip压缩

GZip压缩算法是一种常见的压缩算法，它使用DEFLATE算法来压缩数据。在C#中，我们可以使用`System.IO.Compression`命名空间下的`GZipStream`类来进行GZip压缩。

```C#
static void Main(string[] args)
{
    string sourceFile = "D:\\BaiduSyncdisk\\11Test\\测试导入数据.csv";
    string compressedFile = "D:\\BaiduSyncdisk\\11Test\\compressed.gz";

    using (FileStream sourceStream = new FileStream(sourceFile, FileMode.Open))
    {
        using (FileStream compressedStream = File.Create(compressedFile))
        {
            using (GZipStream compressionStream = new GZipStream(compressedStream, CompressionMode.Compress))
            {
                sourceStream.CopyTo(compressionStream);
            }
        }
    }

    Console.WriteLine("Compression complete.");
}


```




![image.png](https://www.otteach.cn/static/img/bfed8bb84faa4974a31e983630bc1ed1.image.webp)
### Deflate压缩

Deflate压缩算法是GZip压缩算法的基础，也是一种常用的压缩算法。在C#中，我们可以使用`System.IO.Compression`命名空间下的`DeflateStream`类来进行Deflate压缩。

```C#
static void Main(string[] args)
{
    string sourceFile = "D:\\BaiduSyncdisk\\11Test\\测试导入数据.csv";
    string compressedFile = "D:\\BaiduSyncdisk\\11Test\\compressed.deflate";

    using (FileStream sourceStream = new FileStream(sourceFile, FileMode.Open))
    {
        using (FileStream compressedStream = File.Create(compressedFile))
        {
            using (DeflateStream compressionStream = new DeflateStream(compressedStream, CompressionMode.Compress))
            {
                sourceStream.CopyTo(compressionStream);
            }
        }
    }

    Console.WriteLine("Compression complete.");
}



```

### GZip解压

在C#中，我们可以使用`System.IO.Compression`命名空间下的`GZipStream`类来进行GZip解压。

```C#
static void Main(string[] args)
{
    string compressedFile = "D:\\BaiduSyncdisk\\11Test\\compressed.gz";
    string decompressedFile = "D:\\BaiduSyncdisk\\11Test\\测试导入数据1.csv";

    using (FileStream compressedStream = new FileStream(compressedFile, FileMode.Open))
    {
        using (FileStream decompressedStream = File.Create(decompressedFile))
        {
            using (GZipStream decompressionStream = new GZipStream(compressedStream, CompressionMode.Decompress))
            {
                decompressionStream.CopyTo(decompressedStream);
            }
        }
    }

    Console.WriteLine("Decompression complete.");
}


```


![image.png](https://www.otteach.cn/static/img/c6850cfa7991f2d6d65babb86ec4fade.image.webp)

### Deflate解压

在C#中，我们可以使用`System.IO.Compression`命名空间下的`DeflateStream`类来进行Deflate解压。

```C#
static void Main(string[] args)
{
    string compressedFile = "D:\\BaiduSyncdisk\\11Test\\compressed.deflate";
    string decompressedFile = "D:\\BaiduSyncdisk\\11Test\\测试导入数据2.csv";

    using (FileStream compressedStream = new FileStream(compressedFile, FileMode.Open))
    {
        using (FileStream decompressedStream = File.Create(decompressedFile))
        {
            using (DeflateStream decompressionStream = new DeflateStream(compressedStream, CompressionMode.Decompress))
            {
                decompressionStream.CopyTo(decompressedStream);
            }
        }
    }


    Console.WriteLine("Decompression complete.");
}


```


![image.png](https://www.otteach.cn/static/img/ba0dc91e711ed2086f052d26b3f13dae.image.webp)

## 总结

通过使用C#中的压缩和解压算法，我们可以轻松地实现文件的压缩和解压操作。以上示例代码演示了使用GZip和Deflate算法进行压缩和解压的基本用法。根据实际需求和场景，我们还可以选择其他的压缩算法来进行数据处理。

C# 文件压缩与解压Gzip与Deflate

IoTClient是一个开源的物联网通讯协议库，支持多种工业协议，包括西门子(SIEMENS)PLC的通讯。本文将详细介绍如何使用IoTClient与SIEMENS PLC进行通讯。

**我这里用的仿真 Advanced V5.0**


![image.png](https://www.otteach.cn/static/img/a0c8fbd60914f08dfa6255b32825548f.image.webp)

## 安装

首先，通过NuGet包管理器安装IoTClient：

```C#
Install-Package IoTClient
```



或者在项目中添加包引用：

```XML
<PackageReference Include="IoTClient" Version="x.x.x" />
```

## 初始化连接

使用SiemensClient类来创建与PLC的连接：

```C#
client = new SiemensClient(SiemensVersion.S7_1500, "192.168.0.10", 102);
client.Open();
if (client.Connected)
{
    stsMain_lblStatus.Text = "Connected";
}
else
{
    stsMain_lblStatus.Text = "Disconnected";
}


```

参数说明：

- `SiemensVersion.S7_1200`：PLC型号，可选S7_200、S7_300、S7_400、S7_1200、S7_1500等
- `"192.168.0.10"`：PLC的IP地址
- `102`：通讯端口，通常为102

## 读取数据


![image.png](https://www.otteach.cn/static/img/1b1605ee6170e375d5c0be78e74a4d55.image.webp)

### 读取布尔值

```C#
var result = client.ReadBoolean("DB1.0");
if (result.IsSucceed)
{
   MessageBox.Show($"DB1.0的值为：{result.Value}");
}
else
{
    MessageBox.Show($"读取失败：{result.Err}");
}

```

### 读取短整型

```C#
var result = client.ReadInt16("DB1.DBW2");
if (result.IsSucceed)
{
    MessageBox.Show($"DB1.DBW2的值为：{result.Value}");
}

```

### 读取整型

```C#
var result = client.ReadInt32("DB1.DBD4");
if (result.IsSucceed)
{
    MessageBox.Show($"DB1.DBW4的值为：{result.Value}");
}

```

### 读取浮点型

```C#
var result = client.ReadFloat("DB1.DBD8");
if (result.IsSucceed)
{
    MessageBox.Show($"DB1.DBW8的值为：{result.Value}");
}

```

### 读取字符串

```C#
var result = client.ReadString("DB1.DBW16", 10); // 读取10个字符
if (result.IsSucceed)
{
    //西门子协议比较特殊，需要跳过前2个字节,以后讲S7协议解析数据细说
    byte[] bytes = result.Value.Skip(2).ToArray();
    string msg=System.Text.Encoding.Default.GetString(bytes);
    MessageBox.Show($"DB1.DBW16的值为：{msg}");
}

```

## 写入数据

### 写入布尔值

```text
var result = client.Write("DB1.0", true);
if (result.IsSucceed)
{
    MessageBox.Show("写入成功");
}
else
{
    MessageBox.Show($"写入失败：{result.Err}");
}

```

### 写入短整型

```C#
var result = client.Write("DB1.DBW2", (short)12345);
if (result.IsSucceed)
{
    MessageBox.Show("写入成功");
}
else
{
    MessageBox.Show($"写入失败：{result.Err}");
}

```

### 写入整型

```C#
var result = client.Write("DB1.DBD4", 123456789);
if (result.IsSucceed)
{
    MessageBox.Show("写入成功");
}
else
{
    MessageBox.Show($"写入失败：{result.Err}");
}

```

### 写入浮点型

```C#
var result = client.Write("DB1.DBD8", 3.14159f);
if (result.IsSucceed)
{
    MessageBox.Show("写入成功");
}
else
{
    MessageBox.Show($"写入失败：{result.Err}");
}

```

### 写入字符串

```C#
var result = client.Write("DB1.DBW16", "Hello PLC");
if (result.IsSucceed)
{
    MessageBox.Show("写入成功");
}
else
{
    MessageBox.Show($"写入失败：{result.Err}");
}

```

注意：如果是用这种方式写入的，对于读取时不需要Skip(2)了。

## 批量读取

批量读取可以提高效率：

```C#
Dictionary<string, DataTypeEnum> addresses = new Dictionary<string, DataTypeEnum>
{
    { "DB1.DBX0.0", DataTypeEnum.Bool },
    { "DB1.DBW2", DataTypeEnum.Int16 },
    { "DB1.DBD4", DataTypeEnum.Int32 },
    { "DB1.DBD8", DataTypeEnum.Float }
};

var results = client.BatchRead(addresses);

foreach (var item in results.Value)
{
    MessageBox.Show($"{item.Key}的值为：{item.Value}");
}

```

## 批量写入

同样，批量写入也可以提高效率：

```C#
Dictionary<string, object> values = new Dictionary<string, object>
{
    { "DB1.DBX0.0", true },
    { "DB1.DBW2", (short)123 },
    { "DB1.DBD4", 567 },
    { "DB1.DBD8", 1.09922 }
};

var result = client.BatchWrite(values);
if (result.IsSucceed)
{
    MessageBox.Show("批量写入成功");
}
else
{
    MessageBox.Show($"批量写入失败：{result.Err}");
}

```

## 注意事项

|C#数据类型|smart200|1200/1500/300|
|-|-|-|
|bit|V1.0|DB1.DBX1.0|
|byte|VB1|DB1.DBB1|
|shor   ushort|VW2|DB1.DBW2|
|int   uint   float|VD4|DB1.DBD4|


1. 地址格式：
    - 位地址：DBx.DBXy.z，如DB1.DBX0.0
    - 字地址：DBx.DBWy，如DB1.DBW0
    - 双字地址：DBx.DBDy，如DB1.DBD0
2. 数据类型：写入时需要明确数据类型，例如：

```C#
client.Write("DB1.DBD0", (float)3.14); // 明确指定为float类型
```
3. 连接管理：
    - 如果频繁读写，建议保持连接打开状态
    - 使用完毕后记得关闭连接：`client.Close();`
4. 错误处理：每次操作都应检查IsSucceed属性，并适当处理错误情况
5. 批量操作：对于需要读写多个地址的场景，优先使用BatchRead和BatchWrite方法以提高效率

## 结语

IoTClient提供了简单易用的API来与SIEMENS PLC进行通讯。通过本文的示例，您应该能够轻松实现与PLC的数据交互。在实际应用中，请确保考虑到网络状况、错误处理、性能优化等因素，以构建稳定可靠的通讯系统。

IoTClient与SIEMENS PLC通讯详解

## 引入IoTClient库

首先，我们需要在项目中引入IoTClient库。可以通过NuGet包管理器安装：

```C#
Install-Package IoTClient
```

或者在Visual Studio的NuGet包管理器中搜索"IoTClient"并安装。


![image.png](https://www.otteach.cn/static/img/2fdcf06c6222e103eef37acbb7a54ed8.image.webp)

以下例子都是用IotClient Tools仿真测试的。


![image.png](https://www.otteach.cn/static/img/be6e1ee2c5d4f084f77bbeaff0273c49.image.webp)



## 初始化MitsubishiClient

要与三菱PLC通信，我们需要使用`MitsubishiClient`类。以下是初始化客户端的示例：

```C#
// 初始化客户端，使用Qna_3E协议，IP地址为"127.0.0.1"，端口为6000
MitsubishiClient client = new MitsubishiClient(MitsubishiVersion.Qna_3E, "127.0.0.1", 6000);

```

## 连接到PLC

建议在进行读写操作之前先打开连接，以提高效率：

```C#
client.Open();
if (client.Connected)
{
    Console.WriteLine("连接成功！");
}
else
{
    Console.WriteLine("连接失败！");
}

```

## 读取PLC数据

IoTClient提供了多种数据类型的读取方法。以下是一些例子：

### 读取布尔值

```C#
var boolResult = client.ReadBoolean("M100");
if (boolResult.IsSucceed)
{
    Console.WriteLine($"M100的值为：{boolResult.Value}");
}
else
{
    Console.WriteLine($"读取失败：{boolResult.Err}");
}
```

![image.png](https://www.otteach.cn/static/img/9a2818b7cc367f70b0f1f6e2d049db15.image.webp)

### 读取短整型

```C#
var shortResult = client.ReadInt16("D200");
if (shortResult.IsSucceed)
{
    Console.WriteLine($"D200的值为：{shortResult.Value}");
}
else
{
    Console.WriteLine($"读取失败：{shortResult.Err}");
}
```

### 读取整型

```C#
var intResult = client.ReadFloat("D210");
if (intResult.IsSucceed)
{
    Console.WriteLine($"D210-D211的值为：{intResult.Value}");
}
else
{
    Console.WriteLine($"读取失败：{intResult.Err}");
}

```

### 读取浮点

```C#
var intResult = client.ReadInt32("D210");
if (intResult.IsSucceed)
{
    Console.WriteLine($"D210-D211的值为：{intResult.Value}");
}
else
{
    Console.WriteLine($"读取失败：{intResult.Err}");
}
```

## 写入PLC数据

同样，IoTClient也提供了多种数据类型的写入方法：

### 写入布尔值

```C#
var writeBoolResult = client.Write("M100", true);
if (writeBoolResult.IsSucceed)
{
    Console.WriteLine("M100写入成功");
}
else
{
    Console.WriteLine($"写入失败：{writeBoolResult.Err}");
}
```

### 写入短整型

```C#
var writeShortResult = client.Write("D200", (short)12345);
if (writeShortResult.IsSucceed)
{
    Console.WriteLine("D200写入成功");
}
else
{
    Console.WriteLine($"写入失败：{writeShortResult.Err}");
}
```

### 写入整型

```C#
var writeIntResult = client.Write("D210", 123456789);
if (writeIntResult.IsSucceed)
{
    Console.WriteLine("D210-D211写入成功");
}
else
{
    Console.WriteLine($"写入失败：{writeIntResult.Err}");
}
```


![image.png](https://www.otteach.cn/static/img/b7c5d9f26fb3d96b5afad6b467b17c67.image.webp)

## 批量读取

IoTClient还支持批量读取，这可以显著提高效率：

```C#
Dictionary<string, DataTypeEnum> addresses = new Dictionary<string, DataTypeEnum>
{
    { "D200", DataTypeEnum.Int16 },
    { "D210", DataTypeEnum.Float }
};

var batchReadResult = client.BatchRead(addresses,0);

if (batchReadResult.IsSucceed)
{
    foreach (var item in batchReadResult.Value)
    {
        Console.WriteLine($"地址：{item.Key}，值：{item.Value}");
    }
}
else
{
    Console.WriteLine($"批量读取失败：{batchReadResult.Err}");
}

```

简单阅读了一下源代码，发现有些类型在批量读取是会报异常，再就是batchNumber暂时没有用到

不过简单修改一下代码，批量读是没有问题, 以下是读取bool的。

```C#
tempVaue = ReadBoolean(item.TypeChar + item.BeginAddress.ToString()).Value;
```


![image.png](https://www.otteach.cn/static/img/5206614aae7e034fe40b25c99ff02721.image.webp)

## 批量写入

同样，批量写入也是支持的：

这个方法还没有具体实现


![image.png](https://www.otteach.cn/static/img/addbdf155b2b75af7c9230680b09bd3c.image.webp)

简单实现一下这个方法

```C#
public Result BatchWrite(Dictionary<string, object> addresses, int batchNumber)
{
    var result = new Result<Dictionary<string, object>>();
    result.Value = new Dictionary<string, object>();
    foreach (var item in addresses)
    {
        var address = item.Key;
        var value = item.Value;
        // 使用反射将 object 转换回元组
        var type = value.GetType();
        if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ValueTuple<,>))
        {
            // 获取元组的元素
            var firstItem = type.GetField("Item1").GetValue(value);
            var secondItem = type.GetField("Item2").GetValue(value);
            switch (secondItem)
            {
                case DataTypeEnum.Bool:
                    Write(address, Convert.ToBoolean(firstItem));
                    break;
                case DataTypeEnum.Int16:
                    Write(address, Convert.ToInt16(firstItem));
                    break;
                case DataTypeEnum.Int32:
                    Write(address, Convert.ToInt32(firstItem));
                    break;
                case DataTypeEnum.Float:
                    Write(address, Convert.ToSingle(firstItem));
                    break;
                default:
                    throw new Exception("Err BatchWrite 未定义类型 -1");
            }
        }

       
    }
    return result.EndTime();
}

```

```Markdown
Dictionary<string, object> writeValues = new Dictionary<string, object>
{
    { "M100", (true,DataTypeEnum.Bool) },
    { "D200", (12345,DataTypeEnum.Int16) },
    { "D210", (98.34,DataTypeEnum.Float) }
};

var batchWriteResult = client.BatchWrite(writeValues, 10);

if (batchWriteResult.IsSucceed)
{
    Console.WriteLine("批量写入成功");
}
else
{
    Console.WriteLine($"批量写入失败：{batchWriteResult.Err}");
}

```

## 错误处理

在进行读写操作时，我们应该始终检查操作是否成功，并适当处理错误：

```C#
var result = client.ReadInt16("D200");
if (result.IsSucceed)
{
    Console.WriteLine($"读取成功，值为：{result.Value}");
}
else
{
    Console.WriteLine($"读取失败，错误信息：{result.Err}");
    Console.WriteLine($"请求报文：{result.Requst}");
    Console.WriteLine($"响应报文：{result.Response}");
}
```

## 9. 关闭连接

在完成所有操作后，记得关闭连接：

```C#
client.Close();
```

通过使用IoTClient库，我们可以轻松地实现与三菱PLC的通信，大大简化了工业自动化和物联网应用的开发过程。希望这篇文章能够帮助您更好地理解和使用IoTClient与三菱PLC进行通信。

IoTClient与三菱PLC通讯详解

IoTClient是一个功能强大的物联网通信库,支持多种工业协议,包括欧姆龙PLC的Fins协议。本文将详细介绍如何使用IoTClient与欧姆龙PLC进行通信,实现数据读写操作。

## 安装IoTClient

首先,我们需要在项目中安装IoTClient库。可以通过NuGet包管理器安装:

```C#
Install-Package IoTClient
```

或者在Visual Studio的NuGet包管理器中搜索"IoTClient"并安装。

以下例子中，为直接下载IotClient源代码项目引用，方向代码测试。



## 创建OmronFinsClient实例

要与欧姆龙PLC通信,我们需要创建一个`OmronFinsClient`实例:

```C#
using IoTClient.Clients.PLC;

// 创建OmronFinsClient实例,参数为PLC的IP地址和端口号
OmronFinsClient client = new OmronFinsClient("127.0.0.1", 9600);
```

## 连接到PLC

虽然`OmronFinsClient`会在每次读写操作时自动连接和断开,但为了提高效率,建议手动打开连接:

```C#
// 创建OmronFinsClient实例,参数为PLC的IP地址和端口号
OmronFinsClient client = new OmronFinsClient("127.0.0.1", 9600);
client.Open();
if (client.Connected)
{
    Console.WriteLine("连接成功！");
}
else
{
    Console.WriteLine("连接失败！");
}

```

## 读取PLC数据

### 读取布尔值

```C#
var result = client.ReadBoolean("D100");
if (result.IsSucceed)
{
    bool value = result.Value;
    Console.WriteLine($"D100的值为: {value}");
}
else
{
    Console.WriteLine($"读取失败: {result.Err}");
}

```


![image.png](https://www.otteach.cn/static/img/fdb742905c79e692791985b19538bf75.image.webp)

### 读取短整型

```C#
var result = client.ReadInt16("D200");
if (result.IsSucceed)
{
    short value = result.Value;
    Console.WriteLine($"D200的值为: {value}");
}
else
{
    Console.WriteLine($"读取失败: {result.Err}");
}

```

### 读取整型

```C#
var result = client.ReadInt32("D210");
if (result.IsSucceed)
{
    int value = result.Value;
    Console.WriteLine($"D210的值为: {value}");
}
else
{
    Console.WriteLine($"读取失败: {result.Err}");
}

```

![image.png](https://www.otteach.cn/static/img/4318c66f8bb9142410161b0b3aa261f8.image.webp)

## 写入PLC数据

### 写入布尔值

```C#
var result = client.Write("D100", true);
if (result.IsSucceed)
{
    Console.WriteLine("成功写入D100");
}
else
{
    Console.WriteLine($"写入失败: {result.Err}");
}
```

### 写入短整型

```C#
var result = client.Write("D200", (short)123);
if (result.IsSucceed)
{
    Console.WriteLine("成功写入D200");
}
else
{
    Console.WriteLine($"写入失败: {result.Err}");
}
```


![image.png](https://www.otteach.cn/static/img/f18ecdd60a05773a9f6dfc5fe0f73415.image.webp)

### 写入整型

```C#
var result = client.Write("D210", 12345);
if (result.IsSucceed)
{
    Console.WriteLine("成功写入D210-D211");
}
else
{
    Console.WriteLine($"写入失败: {result.Err}");
}
```

## 批量读取

IoTClient支持批量读取多个地址的数据,这可以显著提高效率:

```C#
Dictionary<string, DataTypeEnum> addresses = new Dictionary<string, DataTypeEnum>
{
    { "D100", DataTypeEnum.Bool },
    { "D200", DataTypeEnum.Int16 },
    { "D210", DataTypeEnum.Int32 }
};

var result = client.BatchRead(addresses);
if (result.IsSucceed)
{
    foreach (var item in result.Value)
    {
        Console.WriteLine($"地址: {item.Key}, 值: {item.Value}");
    }
}
else
{
    Console.WriteLine($"批量读取失败: {result.Err}");
}
```


![image.png](https://www.otteach.cn/static/img/8de333e4f03d5c239392f4ee0b72a572.image.webp)

## 批量写入

同样,IoTClient也支持批量写入操作:

这个BatchWrite在开源代码中同样没有实现，需要自己修改一下，按我写三菱的方式改一下也就可以用了。

```C#
Dictionary<string, object> writeValues = new Dictionary<string, object>
{
    { "D100", (true,DataTypeEnum.Bool) },
    { "D200", (12345,DataTypeEnum.Int16) },
    { "D210", (98.34,DataTypeEnum.Float) }
};

var batchWriteResult = client.BatchWrite(writeValues, 10);

if (batchWriteResult.IsSucceed)
{
    Console.WriteLine("批量写入成功");
}
else
{
    Console.WriteLine($"批量写入失败：{batchWriteResult.Err}");
}

```

![image.png](https://www.otteach.cn/static/img/f16e837af1c02721d5021bfeca20328c.image.webp)

## 错误处理

在进行读写操作时,我们应该始终检查操作是否成功,并适当处理错误:

```C#
var result = client.ReadInt16("D200");
if (result.IsSucceed)
{
    short value = result.Value;
    Console.WriteLine($"D200的值为: {value}");
}
else
{
    Console.WriteLine($"读取失败: {result.Err}");//Requst,Response
    // 这里可以添加更多的错误处理逻辑
}
```

## 关闭连接

当不再需要与PLC通信时,应该关闭连接:

```C#
client.Close();
```

## 结论

通过IoTClient库,我们可以轻松地与欧姆龙PLC进行通信,实现数据的读写操作。该库提供了简单易用的API,支持单个和批量的读写操作,并具有良好的错误处理机制。在实际应用中,我们应该注意正确处理连接和错误,以确保程序的稳定性和可靠性。

使用IoTClient读取欧姆龙PLC的详细应用

IoTClient是一个功能强大的.NET库，用于与各种工业设备和PLC进行通信。在本文中，我们将重点介绍如何使用IoTClient库与罗克韦尔（Allen-Bradley）PLC进行通信，并提供多个详细的示例。

## 安装

首先，我们需要通过NuGet包管理器安装IoTClient库。在Visual Studio中，可以使用以下命令：

```C#
Install-Package IoTClient
```

或者在项目中添加以下包引用：

```XML
<PackageReference Include="IoTClient" Version="1.0.30" />
```

以下例子是在IotClient 源代码下引用项目测试。

仿真用的还是IotClientTool


![image.png](https://www.otteach.cn/static/img/010c07aeff4ade673ee24e75bddb9d53.image.webp)



## 基本用法

### 创建连接

要与罗克韦尔PLC通信，我们首先需要创建一个`AllenBradleyClient`实例：

```C#
using IoTClient.Clients.AllenBradley;

// 创建客户端实例，指定PLC的IP地址和端口
AllenBradleyClient client = new AllenBradleyClient("127.0.0.1", 44818);
```

### 连接

```C#
// 创建客户端实例，指定PLC的IP地址和端口
AllenBradleyClient client = new AllenBradleyClient("127.0.0.1", 44818);

client.Open();
if (client.Connected)
{
    Console.WriteLine("连接成功！");
}
else
{
    Console.WriteLine("连接失败！");
}

```

### 读取短整型数据

```C#
// 读取短整型数据
var shortResult = client.ReadInt16("A1");
if (shortResult.IsSucceed)
{
    Console.WriteLine($"A1的值为：{shortResult.Value}");
}
else
{
    Console.WriteLine($"读取失败：{shortResult.Err}");
}

```


![image.png](https://www.otteach.cn/static/img/4175681ab8a62bb5c59b9c46b66e37ca.image.webp)

### 读取整型数据

```C#
var intResult = client.ReadInt32("B10");
if (intResult.IsSucceed)
{
    Console.WriteLine($"B10的值为：{intResult.Value}");
}
else
{
    Console.WriteLine($"读取失败：{intResult.Err}");
}

```


![image.png](https://www.otteach.cn/static/img/637c9ef0d7450a6e583596a10069dd0e.image.webp)
### 读取浮点型数据

```Markdown
var floatResult = client.ReadFloat("C20");
if (floatResult.IsSucceed)
{
    Console.WriteLine($"C20的值为：{floatResult.Value}");
}
else
{
    Console.WriteLine($"读取失败：{floatResult.Err}");
}

```

![image.png](https://www.otteach.cn/static/img/65385d9843e1a4280ae8cd74d687970e.image.webp)

### 读取布尔型数据

```C#
// 读取布尔型数据
var boolResult = client.ReadBoolean("X0");
if (boolResult.IsSucceed)
{
    Console.WriteLine($"X0的状态为：{boolResult.Value}");
}
else
{
    Console.WriteLine($"读取失败：{boolResult.Err}");
}

```


![image.png](https://www.otteach.cn/static/img/651647c61aa78c4f7549cb57a80787fe.image.webp)

### 批量读

在源代码中，批量读写都没有相应的实现。

![image.png](https://www.otteach.cn/static/img/3992f475f9ca22544a3e39a153925630.image.webp)

 简单实现，这个批量根上还是一个个读取，这块比不上SIEMENS S7.net中的按byte批量。

```C#
public Result<Dictionary<string, object>> BatchRead(Dictionary<string, DataTypeEnum> addresses, int batchNumber)
{
    var result = new Result<Dictionary<string, object>>();
    result.Value = new Dictionary<string, object>();
    foreach (var item in addresses)
    {
        var address = item.Key;
        var value = item.Value;

        object tempVaue = null;
        switch (value)
        {
            //这里可以按单个读写判断是否成功，返回参数再丰富一些。
            case DataTypeEnum.Bool:
                tempVaue = ReadBoolean(address).Value;
                break;
            case DataTypeEnum.Int16:
                tempVaue = ReadInt16(address).Value;
                break;
            case DataTypeEnum.Int32:
                tempVaue = ReadInt32(address).Value;
                break;
            case DataTypeEnum.Float:
                tempVaue = ReadFloat(address).Value;
                break;
            default:
                throw new Exception("Err BatchRead 未定义类型 -1");
        }
        result.Value.Add(address, tempVaue);
    }
    return result;
}

```

![image.png](https://www.otteach.cn/static/img/3c4d9d8c286a24f98e33901ff78a17f9.image.webp)

### 写入数据

同样，我们可以向PLC写入数据：

```TypeScript
// 写入短整型数据
var writeShortResult = client.Write("A1", (short)100);
if (writeShortResult.IsSucceed)
{
    Console.WriteLine("写入A1成功");
}
else
{
    Console.WriteLine($"写入A1失败：{writeShortResult.Err}");
}

// 写入整型数据
var writeIntResult = client.Write("B10", 1000);

// 写入浮点型数据
var writeFloatResult = client.Write("C20", 3.14f);

// 写入布尔型数据
var writeBoolResult = client.Write("X0", true);
```

同样，这个项目中批量的也没实现，方法类似，与我在三菱中的批量写一样，其实也是调整单个写完成的。

## 高级用法

### 使用长连接

为了提高性能，特别是在频繁读写的场景下，我们可以使用长连接：

```C#
client.Open();

try
{
    // 执行多次读写操作
    for (int i = 0; i < 100; i++)
    {
        var result = client.ReadInt16($"A{i}");
        // 处理结果...
    }
}
finally
{
    client.Close();
}
```

## 错误处理

在与PLC通信时，错误处理是非常重要的。每个读写操作都会返回一个包含操作结果的对象：

```C#
var result = client.ReadInt16("A1");

if (result.IsSucceed)
{
    Console.WriteLine($"读取成功，值为：{result.Value}");
}
else
{
    Console.WriteLine($"读取失败，错误信息：{result.Err}");
    Console.WriteLine($"请求报文：{result.Requst}");
    Console.WriteLine($"响应报文：{result.Response}");
}
```

## 结论

IoTClient库为与罗克韦尔PLC通信提供了一个简单而强大的接口。通过本文提供的示例，您应该能够轻松地在自己的C#项目中实现与罗克韦尔PLC的通信。记住要正确处理错误，并在适当的情况下使用长连接和异步操作来优化性能。

希望这篇文章对您有所帮助！如果您有任何问题或需要进一步的说明，请随时询问。

C# 使用IoTClient读取罗克韦尔PLC数据

google-site-verification

6VPd1sSgMMRcd7LEbHWBHvFCB5l870aZqLrLM7Wij6A

baidu-site-verification

msvalidate.01

google-adsense-account

title

专注开发技术分享的个人博客，提供C#，Python，NodeJs，Java，WPF、.NET、OPC UA、AI开发等实战教程。包含完整项目源码和详细技术解析，助力开发者技能提升。

description

C#开发,WPF教程,Python开发，Java开发,NodeJs开发,.NET编程,OPC UA,AI开发,Semantic Kernel,技术博客,编程教程,工业软件开发，数据库