# FourTank

**Repository Path**: FTDBQZ/four-tank

## Basic Information

- **Project Name**: FourTank
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-06-13
- **Last Updated**: 2026-03-30

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 四釜反应器自动化控制系统 (FourTank-Reactor)

## 项目概述

四釜反应器自动化控制系统是一个基于 .NET 8.0 开发的工业自动化控制平台，专门用于控制和管理四釜反应器设备的各种硬件组件。该系统采用模块化设计，支持多种通信协议和设备类型，提供完整的反应器自动化操作流程。

## 系统架构

系统采用分层架构设计，包含以下核心模块：

```
四釜反应器系统架构
├── WPFTestUI (用户界面层)
│   ├── 设备配置管理
│   ├── 实时设备控制
│   └── 状态监控界面
├── ServiceInterface (服务接口层)
│   ├── 系统初始化服务
│   └── 流程执行服务
├── BusinessProcesses (业务流程层)
│   ├── 液体添加流程
│   ├── 液体回收流程
│   ├── 固体添加流程
│   ├── 气体置换流程
│   ├── 管路清洗流程
│   └── 取样流程
├── DeviceControllers (设备控制层)
│   ├── 电机控制器 (步进/伺服)
│   ├── 注射泵控制器
│   ├── IO控制器
│   ├── 机械手控制器
│   └── 夹爪控制器
├── CommunicationDrivers (通信驱动层)
│   ├── EtherCAT 总线通信
│   ├── CAN 总线通信
│   ├── Modbus RTU 通信
│   └── Socket TCP/IP 通信
└── Shared (共享组件层)
    ├── 配置管理
    ├── 数据传输对象
    └── 公共工具类
```

## 项目模块详解

### 1. WPFTestUI - 用户界面层

**技术栈：** WPF + Prism.DryIoc + HandyControl

**主要功能：**
- **系统初始化与连接管理**：统一管理所有设备的初始化和连接状态
- **设备配置管理**：可视化配置电机、传感器、通信参数等设备信息
- **实时设备控制**：提供步进电机、伺服电机、注射泵等设备的手动操作界面
- **状态监控**：实时显示设备运行状态、位置信息、错误信息等
- **IO控制**：数字和模拟IO端口的控制与监控
- **通信测试**：CAN总线通信功能测试界面

**核心界面模块：**
- `MainWindow` - 主控制界面，系统初始化和导航
- `DeviceConfigView` - 设备参数配置界面
- `StepperMotorControlView` - 步进电机控制界面
- `ServoMotorControlView` - 伺服电机控制界面
- `SyringePumpControlView` - 注射泵控制界面
- `IOControlView` - IO端口控制界面
- `RobotControlView` - 机械手控制界面
- `JunduoGripperControlView` - 钧舵夹爪控制界面

### 2. ServiceInterface - 服务接口层

**主要服务：**

#### FourTankSystemInitializationService - 系统初始化服务
- **功能**：负责整个系统的启动、初始化和关闭流程
- **职责**：
  - 依赖注入容器配置
  - 设备实例创建和管理
  - 通信连接建立
  - 系统状态管理

#### ProcessExecutionService - 流程执行服务
- **功能**：执行各种业务流程和工艺操作
- **职责**：
  - 流程调度和执行
  - 参数验证和传递
  - 执行状态监控
  - 错误处理和恢复

### 3. BusinessProcesses - 业务流程层

**设计模式：** 模板方法模式 + 策略模式

**基础架构：**
- `ProcessBase` - 所有流程的抽象基类，定义了标准的执行模板

**具体业务流程：**

#### LiquidAdditionProcess - 液体添加流程
- **功能**：自动化液体加样操作
- **支持的操作步骤**：
  - 液柜直接加压
  - 管路清洗
  - 机械臂操作
  - 液体推入
  - 管路吹扫
  - 瓶子归位
  - 管路润洗

#### LiquidRecoveryProcess - 液体回收流程
- **功能**：反应后液体的自动回收和处理

#### SolidAdditionProcess - 固体添加流程
- **功能**：固体试剂的自动添加操作

#### GasReplacementProcess - 气体置换流程
- **功能**：反应器内气体环境的控制和置换

#### CleanPipelineProcess - 管路清洗流程
- **功能**：系统管路的自动清洗和维护

#### ProcessSamplingProcess - 取样流程
- **功能**：反应过程中的自动取样操作

### 4. DeviceControllers - 设备控制层

**设备管理器：**
- `DeviceManager` - 统一的设备实例管理器，负责创建、配置和管理所有设备实例

**电机控制：**
- `VSMDMotorController` - VSMD步进电机控制器
- `EtherCATMotorController` - EtherCAT伺服电机控制器
- 支持位置控制、速度控制、回零操作等

**泵控制：**
- `SyringePumpController` - 注射泵控制器
- 支持精确的流量控制和体积控制

**IO控制：**
- `EtherCATIOController` - EtherCAT IO控制器
- 支持数字输入输出和模拟信号处理

**机械手控制：**
- `RobotController` - 机械手控制器
- 支持多轴协调运动和位置管理

**夹爪控制：**
- `JunduoGripperController` - 钧舵夹爪控制器
- 支持精确的夹取力度控制

### 5. CommunicationDrivers - 通信驱动层

**支持的通信协议：**

#### EtherCAT 总线通信
- `EtherCATManager` - EtherCAT主站管理器
- **功能**：高性能实时通信，支持伺服电机和IO模块
- **特性**：微秒级同步、高速数据传输、故障诊断

#### CAN 总线通信
- `ZLGCANManager` - 周立功CAN卡管理器
- **功能**：CAN 2.0A/B协议支持，多通道通信
- **应用**：步进电机控制、传感器数据采集

#### Modbus RTU 通信
- `ModbusRTUManager` - Modbus RTU通信管理器
- **功能**：标准Modbus协议支持
- **应用**：温度传感器、压力变送器等设备通信

#### Socket TCP/IP 通信
- `SocketManager` - TCP/IP Socket通信管理器
- **功能**：以太网通信支持
- **应用**：机械手控制、上位机通信

### 6. Shared - 共享组件层

**配置管理：**
- `FourTankConfigManager` - 配置文件管理器
- `FourTankDeviceParameters` - 设备参数配置类
- 支持JSON格式配置文件的加载、保存和验证

**数据传输对象 (DTOs)：**
- `EtherCATMotorStatus` - EtherCAT电机状态
- `VSMDMotorStatus` - VSMD电机状态
- `RunZeSyringePumpStatus` - 注射泵状态
- `RobotStatus` - 机械手状态
- `JunduoGripperStatus` - 夹爪状态
- `IOSignalDefinitions` - IO信号定义

**公共工具：**
- `OperationResult` - 统一的操作结果封装
- `ProcessHelper` - 流程辅助工具类
- `ProcessUtilities` - 流程工具函数

## 核心技术特性

### 1. 模块化架构
- **松耦合设计**：各模块通过接口交互，易于扩展和维护
- **依赖注入**：使用Prism.DryIoc容器管理依赖关系
- **插件化支持**：新设备和流程可以轻松集成

### 2. 多通信协议支持
- **EtherCAT**：高精度伺服控制，实时性能优异
- **CAN总线**：可靠的现场总线通信
- **Modbus RTU**：工业标准通信协议
- **TCP/IP**：灵活的网络通信

### 3. 实时监控和控制
- **状态更新**：500ms周期的设备状态更新
- **异常处理**：完善的错误检测和恢复机制
- **日志记录**：详细的操作日志和调试信息

### 4. 安全保护机制
- **急停功能**：硬件和软件双重急停保护
- **限位保护**：电机运动限位检测
- **参数验证**：严格的输入参数验证
- **状态检查**：设备状态实时监控

## 第三方项目集成指南

### 系统初始化和设备连接功能集成

如果您想在其他项目中集成本系统的 `InitializeSystemCommand` 和 `ConnectDevicesCommand` 功能，需要按照以下步骤进行服务注册：

#### 1. 基础依赖项引用

首先确保您的项目引用了以下程序集：
- `ServiceInterface.dll`
- `DeviceControllers.dll`
- `CommunicationDrivers.dll`
- `BusinessProcesses.dll`
- `Shared.dll`

#### 2. 必需的NuGet包

```xml
<PackageReference Include="Prism.DryIoc" Version="8.1.97" />
<PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.0" />
<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
```

#### 3. 服务注册代码

在您的依赖注入容器配置中添加以下注册：

```csharp
public void RegisterFourTankServices(IContainerRegistry containerRegistry)
{
    // 1. 基础日志服务
    RegisterLoggingServices(containerRegistry);
    
    // 2. 配置管理服务
    RegisterConfigurationServices(containerRegistry);
    
    // 3. 设备管理服务
    RegisterDeviceServices(containerRegistry);
    
    // 4. 通信驱动服务
    RegisterCommunicationServices(containerRegistry);
    
    // 5. 业务流程服务
    RegisterBusinessProcessServices(containerRegistry);
}

/// <summary>
/// 注册日志服务
/// </summary>
private void RegisterLoggingServices(IContainerRegistry containerRegistry)
{
    // 注册日志工厂
    containerRegistry.RegisterSingleton<ILoggerFactory>(factory =>
    {
        var serviceCollection = new ServiceCollection();
        serviceCollection.AddLogging(builder =>
        {
            builder.SetMinimumLevel(LogLevel.Debug);
            builder.AddDebug();
            // 可以添加其他日志提供程序，如文件日志等
        });
        var serviceProvider = serviceCollection.BuildServiceProvider();
        return serviceProvider.GetRequiredService<ILoggerFactory>();
    });

    // 注册核心服务的Logger
    containerRegistry.Register<ILogger<FourTankSystemInitializationService>>(factory =>
        factory.Resolve<ILoggerFactory>().CreateLogger<FourTankSystemInitializationService>());
    
    containerRegistry.Register<ILogger<DeviceManager>>(factory =>
        factory.Resolve<ILoggerFactory>().CreateLogger<DeviceManager>());
    
    containerRegistry.Register<ILogger<ServiceRegistrationConfigurator>>(factory =>
        factory.Resolve<ILoggerFactory>().CreateLogger<ServiceRegistrationConfigurator>());
}

/// <summary>
/// 注册配置管理服务
/// </summary>
private void RegisterConfigurationServices(IContainerRegistry containerRegistry)
{
    containerRegistry.RegisterSingleton<FourTankConfigManager>();
}

/// <summary>
/// 注册设备管理服务
/// </summary>
private void RegisterDeviceServices(IContainerRegistry containerRegistry)
{
    containerRegistry.RegisterSingleton<DeviceManager>();
    containerRegistry.Register<IDeviceManager>(factory => factory.Resolve<DeviceManager>());
}

/// <summary>
/// 注册通信驱动服务
/// </summary>
private void RegisterCommunicationServices(IContainerRegistry containerRegistry)
{
    // CAN通信Logger
    containerRegistry.Register<ILogger<ZLGCANManager>>(factory =>
        factory.Resolve<ILoggerFactory>().CreateLogger<ZLGCANManager>());
    
    // EtherCAT通信Logger
    containerRegistry.Register<ILogger<EtherCATManager>>(factory =>
        factory.Resolve<ILoggerFactory>().CreateLogger<EtherCATManager>());
    
    // ModbusRTU通信Logger
    containerRegistry.Register<ILogger<ModbusRTUManager>>(factory =>
        factory.Resolve<ILoggerFactory>().CreateLogger<ModbusRTUManager>());
    
    // Socket通信Logger
    containerRegistry.Register<ILogger<SocketManager>>(factory =>
        factory.Resolve<ILoggerFactory>().CreateLogger<SocketManager>());
}

/// <summary>
/// 注册业务流程服务
/// </summary>
private void RegisterBusinessProcessServices(IContainerRegistry containerRegistry)
{
    containerRegistry.RegisterSingleton<ProcessHelper>();
    containerRegistry.Register<ILogger<ProcessHelper>>(factory =>
        factory.Resolve<ILoggerFactory>().CreateLogger<ProcessHelper>());
    
    containerRegistry.RegisterSingleton<ProcessExecutionService>();
    containerRegistry.Register<ILogger<ProcessExecutionService>>(factory =>
        factory.Resolve<ILoggerFactory>().CreateLogger<ProcessExecutionService>());
}
```

#### 4. 使用示例

在您的ViewModel或服务类中使用系统初始化功能：

```csharp
public class YourViewModel : ObservableObject
{
    private readonly IContainerProvider _containerProvider;
    private readonly ILogger<YourViewModel> _logger;
    private FourTankSystemInitializationService _systemService;

    public YourViewModel(IContainerProvider containerProvider, ILogger<YourViewModel> logger)
    {
        _containerProvider = containerProvider;
        _logger = logger;
    }

    [RelayCommand]
    private void InitializeSystem()
    {
        try
        {
            _logger.LogInformation("开始系统初始化...");
            
            // 创建系统初始化服务
            _systemService = new FourTankSystemInitializationService();
            
            // 执行初始化
            bool success = _systemService.InitializeSystem(
                _containerProvider as IContainerRegistry, 
                _containerProvider);
            
            if (success)
            {
                _logger.LogInformation("系统初始化成功");
                // 更新UI状态
            }
            else
            {
                _logger.LogError("系统初始化失败");
                // 处理失败情况
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "系统初始化异常");
        }
    }

    [RelayCommand]
    private async Task ConnectDevices()
    {
        try
        {
            if (_systemService == null || !_systemService.IsInitialized)
            {
                _logger.LogWarning("系统未初始化，请先初始化系统");
                return;
            }

            _logger.LogInformation("开始连接设备...");
            
            bool success = await _systemService.ConnectDevices();
            
            if (success)
            {
                _logger.LogInformation("设备连接成功");
                // 更新UI状态
            }
            else
            {
                _logger.LogError("设备连接失败");
                // 处理失败情况
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "设备连接异常");
        }
    }
}
```

#### 5. 配置文件准备

确保在您的项目中包含配置文件：

```json
// Config/fourtank_config.json
{
  "motors": [
    {
      "deviceId": "motor_1",
      "motorName": "X轴电机",
      "motorType": "VSMD",
      "canDeviceIndex": 0,
      "canChannelIndex": 0,
      "nodeId": 1,
      "maxPosition": 10000,
      "minPosition": 0,
      "homePosition": 0,
      "maxSpeed": 3000,
      "acceleration": 1000,
      "deceleration": 1000
    }
  ],
  "canDevices": [
    {
      "deviceId": "can_device_1",
      "deviceName": "CAN卡1",
      "deviceType": "USBCAN",
      "deviceIndex": 0,
      "channelCount": 2,
      "baudRate": 250000
    }
  ],
  "etherCATDevices": [
    {
      "deviceId": "ecat_master_1",
      "deviceName": "EtherCAT主站",
      "cardId": 0,
      "configFilePath": "Config/EtherCAT.xml"
    }
  ],
  "syringePumps": [
    {
      "deviceId": "pump_1",
      "pumpName": "注射泵1",
      "pumpType": "RunZe",
      "canDeviceIndex": 0,
      "canChannelIndex": 0,
      "nodeId": 10,
      "maxVolume": 100.0,
      "maxFlowRate": 50.0
    }
  ]
}
```

#### 6. 简化集成方案

如果您不想手动注册所有服务，可以直接使用 `ServiceRegistrationConfigurator`：

```csharp
public void RegisterFourTankServices(IContainerRegistry containerRegistry)
{
    // 先注册基础日志服务
    RegisterBasicLoggingServices(containerRegistry);
    
    // 使用ServiceRegistrationConfigurator自动注册所有服务
    var loggerFactory = containerRegistry.Resolve<ILoggerFactory>();
    var logger = loggerFactory.CreateLogger<ServiceRegistrationConfigurator>();
    var configurator = new ServiceRegistrationConfigurator(logger);
    
    configurator.RegisterAllNonUIServices(containerRegistry);
}

private void RegisterBasicLoggingServices(IContainerRegistry containerRegistry)
{
    containerRegistry.RegisterSingleton<ILoggerFactory>(factory =>
    {
        var serviceCollection = new ServiceCollection();
        serviceCollection.AddLogging(builder =>
        {
            builder.SetMinimumLevel(LogLevel.Debug);
            builder.AddDebug();
        });
        var serviceProvider = serviceCollection.BuildServiceProvider();
        return serviceProvider.GetRequiredService<ILoggerFactory>();
    });
}
```

#### 7. 注意事项

1. **配置文件路径**：确保配置文件 `fourtank_config.json` 在正确的路径下
2. **硬件驱动**：确保相关硬件驱动（如EtherCAT、CAN卡驱动）已正确安装
3. **权限要求**：某些硬件操作可能需要管理员权限
4. **线程安全**：设备操作建议在后台线程中执行，避免阻塞UI
5. **资源释放**：应用程序关闭时调用 `_systemService.ShutdownSystem()` 释放资源

通过以上步骤，您就可以在自己的项目中集成四釜反应器系统的初始化和设备连接功能了。

## 快速开始

### 系统要求
- **操作系统**：Windows 10/11 (x64)
- **.NET 运行时**：.NET 8.0 Runtime
- **硬件接口**：
  - EtherCAT主站卡
  - CAN通信卡（周立功）
  - 串口（Modbus RTU）
  - 以太网接口

### 安装和配置

1. **克隆项目**
   ```bash
   git clone <repository-url>
   cd four-tank
   ```

2. **编译项目**
   ```bash
   dotnet build FourTank-Reactor.sln --configuration Release
   ```

3. **配置设备参数**
   - 运行程序后进入"设备配置"模块
   - 根据实际硬件配置设备参数
   - 保存配置文件

4. **启动系统**
   - 运行 `WPFTestUI.exe`
   - 点击"系统初始化"
   - 点击"连接设备"

### 基本使用流程

#### 1. 系统初始化
```csharp
// 系统初始化示例
var initService = new FourTankSystemInitializationService();
bool success = initService.InitializeSystem(containerRegistry, containerProvider);
```

#### 2. 设备连接
```csharp
// 连接所有配置的设备
bool connected = await initService.ConnectDevices();
```

#### 3. 执行业务流程
```csharp
// 执行液体添加流程示例
var parameters = new Dictionary<string, object>
{
    ["StepType"] = "LIQUIDCABINET_DIRECT_PRESSURE",
    ["MaterialName"] = "试剂A",
    ["Volume"] = 50.0
};

var process = new LiquidAdditionProcess(logger, deviceManager, processHelper, configManager);
var result = await process.ExecuteAsync(parameters);
```

## 配置文件说明

系统使用JSON格式的配置文件 `Config/fourtank_config.json`：

```json
{
  "motors": [
    {
      "deviceId": "motor_1",
      "motorName": "X轴电机",
      "motorType": "VSMD",
      "canDeviceIndex": 0,
      "canChannelIndex": 0,
      "nodeId": 1,
      "maxPosition": 10000,
      "minPosition": 0,
      "homePosition": 0,
      "maxSpeed": 3000,
      "acceleration": 1000,
      "deceleration": 1000
    }
  ],
  "canDevices": [
    {
      "deviceId": "can_device_1",
      "deviceName": "CAN卡1",
      "deviceType": "USBCAN",
      "deviceIndex": 0,
      "channelCount": 2,
      "baudRate": 250000
    }
  ],
  "etherCATDevices": [
    {
      "deviceId": "ecat_master_1",
      "deviceName": "EtherCAT主站",
      "cardId": 0,
      "configFilePath": "Config/EtherCAT.xml"
    }
  ],
  "syringePumps": [
    {
      "deviceId": "pump_1",
      "pumpName": "注射泵1",
      "pumpType": "RunZe",
      "canDeviceIndex": 0,
      "canChannelIndex": 0,
      "nodeId": 10,
      "maxVolume": 100.0,
      "maxFlowRate": 50.0
    }
  ]
}
```

## API 使用示例

### 电机控制示例
```csharp
// 获取电机实例
var motor = deviceManager.GetMotorInstance("motor_1");

// 使能电机
await motor.EnableAsync();

// 回零操作
await motor.HomeAsync();

// 移动到指定位置
await motor.MoveToPositionAsync(5000, 2000);

// 获取当前位置
int currentPosition = await motor.GetCurrentPositionAsync();
```

### 注射泵控制示例
```csharp
// 获取注射泵实例
var pump = deviceManager.GetSyringePumpInstance("pump_1");

// 设置流速并开始注射
await pump.SetFlowRateAsync(10.0); // 10 mL/min
await pump.StartInfuseAsync();

// 注射指定体积
await pump.InfuseVolumeAsync(25.0); // 25 mL

// 停止注射
await pump.StopAsync();
```

### IO控制示例
```csharp
// 获取IO控制器
var ioController = deviceManager.GetIOControllerInstance();

// 设置数字输出
await ioController.SetDigitalOutputAsync(0, true);

// 读取数字输入
bool inputState = await ioController.GetDigitalInputAsync(1);

// 读取模拟输入
double analogValue = await ioController.GetAnalogInputAsync(0);
```

## 故障排除

### 常见问题

1. **设备连接失败**
   - 检查硬件连接和电源
   - 确认设备驱动已正确安装
   - 验证配置文件中的设备参数

2. **通信超时**
   - 检查通信线缆连接
   - 确认波特率和通信参数设置
   - 检查设备地址配置

3. **电机运动异常**
   - 检查限位开关状态
   - 确认电机使能状态
   - 验证运动参数设置

4. **流程执行失败**
   - 查看详细错误日志
   - 检查设备状态和连接
   - 验证流程参数

### 日志分析
系统提供详细的日志信息，日志级别包括：
- **Information**：正常操作信息
- **Warning**：警告信息
- **Error**：错误信息
- **Debug**：调试信息

## 开发指南

### 添加新设备类型

1. **定义设备接口**
   ```csharp
   public interface INewDevice : IDeviceBase
   {
       Task<bool> CustomOperationAsync();
   }
   ```

2. **实现设备类**
   ```csharp
   public class NewDevice : INewDevice
   {
       // 实现设备功能
   }
   ```

3. **注册到设备管理器**
   ```csharp
   // 在DeviceManager中添加设备创建逻辑
   ```

### 添加新业务流程

1. **继承ProcessBase**
   ```csharp
   public class NewProcess : ProcessBase
   {
       public override string ProcessName => "新流程";
       public override string ProcessDescription => "新流程描述";
       
       protected override OperationResult ValidateParameters(Dictionary<string, object> parameters)
       {
           // 参数验证逻辑
       }
       
       protected override async Task<OperationResult> ExecuteMainProcessAsync(Dictionary<string, object> parameters)
       {
           // 流程执行逻辑
       }
   }
   ```

## 版本历史

- **v1.0.0** - 初始版本，基础设备控制功能
- **v1.1.0** - 添加业务流程模块
- **v1.2.0** - 完善用户界面和配置管理
- **v1.3.0** - 增强错误处理和日志功能

## 技术支持

如有技术问题或建议，请联系开发团队：

- **项目负责人**：[联系信息]
- **技术支持**：[联系信息]
- **问题反馈**：[Issue 链接]

## 许可证

本项目采用 [许可证类型] 许可证，详见 LICENSE 文件。

---

**注意：** 本系统涉及工业设备控制，使用前请确保操作人员具备相应的技术知识和安全意识。在生产环境中使用前，请进行充分的测试和验证。