IO控制 API 文档

文档信息

项目	内容
版本	1.1.0
状态	正式版
编写日期	2025-12-18
最后更新	2025-12-18
编写人	MIMO 开发团队

更新日志

版本	日期	更新内容	编写人
1.1.0	2025-12-18	根据实际代码更新接口定义	MIMO 开发团队
1.0.0	2025-12-16	初始版本	MIMO 开发团队

1. 概述

本文档详细介绍了 MIMO 系统中 IO 控制相关的 API 接口，包括 IO 管理器接口 I_IOManager。这些 API 提供了对系统输入输出信号的统一管理和控制功能。

2. IO管理器接口

2.1 I_IOManager 接口

I_IOManager 是 IO 控制模块的核心接口，定义了对 IO 信号进行管理和操作的基本方法。

namespace DeviceLibrary
{
    public interface I_IOManager
    {
         /// <summary>
         /// 连接IO设备列表
         /// </summary>
         bool ConnectionIOList(List<string> dIODeviceNameList);

         /// <summary>
         /// 读取所有DI信号
         /// </summary>
         void ReadAllDI(string deviceName, byte slaveId); 

         /// <summary>
         /// 读取所有DO信号
         /// </summary>
         void ReadAllDO(string deviceName, byte slaveId);

         /// <summary>
         /// 写入单个DO信号 (带延时)
         /// </summary>
         void WriteSingleDO(string deviceName, byte slaveId, ushort index, IO_VALUE value, int time);

         /// <summary>
         /// 写入单个DO信号
         /// </summary>
         void WriteSingleDO(string deviceName, byte slaveId, ushort index, IO_VALUE value);

         /// <summary>
         /// 获取DI信号值
         /// </summary>
         IO_VALUE GetDIValue(string deviceName, byte slaveID, ushort v);

         /// <summary>
         /// 获取DO信号值
         /// </summary>
         IO_VALUE GetDOValue(string deviceName, byte slaveID, ushort v);

         /// <summary>
         /// 根据配置对象获取IO值
         /// </summary>
         IO_VALUE GetIOValue(ConfigIO configIO);

         /// <summary>
         /// 关闭所有DO
         /// </summary>
         void CloseAllDO();

         /// <summary>
         /// 关闭所有连接
         /// </summary>
         void CloseAllConnection();
    }
}

2.2 数据类型

IO_VALUE 枚举

public enum IO_VALUE
{
    LOW = 0,
    HIGH = 1,
    None = 2
}

4. 监控接口

4.1 IOMonitor 类

IOMonitor 类用于监控 IO 状态变化，提供实时的 IO 状态更新和事件通知。

public class IOMonitor
{
    /// <summary>
    /// 初始化IO监控器
    /// </summary>
    /// <param name="ioManager">IO管理器实例</param>
    public IOMonitor(I_IOManager ioManager);

    /// <summary>
    /// 开始监控
    /// </summary>
    /// <param name="scanIntervalMs">扫描间隔（毫秒）</param>
    public void StartMonitoring(int scanIntervalMs = 50);

    /// <summary>
    /// 停止监控
    /// </summary>
    public void StopMonitoring();

    /// <summary>
    /// IO状态变化事件
    /// </summary>
    public event Action<int, bool, bool> IOStateChanged; // 参数：IO点ID，旧状态，新状态

    /// <summary>
    /// 监控状态事件
    /// </summary>
    public event Action<bool> MonitoringStateChanged; // 参数：是否正在监控
}

5. 具体实现类

5.1 IOManager 类

IOManager 是 I_IOManager 接口的具体实现类，负责实际的 IO 控制操作。

public class IOManager : I_IOManager
{
    // 实现 I_IOManager 接口的所有方法
    // ...
}

6. 异常处理

IO 控制模块定义了特定的异常类型，用于表示不同类型的 IO 操作异常：

• IOInitializationException：IO 初始化异常
• IOCommunicationException：IO 通信异常
• IOOperationException：IO 操作异常
• IOTimeoutException：IO 操作超时异常
• IOConfigException：IO 配置异常

这些异常都继承自 DeviceException 基类。

7. 使用示例

7.1 基本用法

// 创建并初始化IO管理器
I_IOManager ioManager = new IOManager();
if (ioManager.Initialize())
{
    try
    {
        // 读取输入点10的状态
        bool inputState = ioManager.ReadInput(10);
        Console.WriteLine($"Input 10 state: {inputState}");

        // 写入输出点5为true
        if (ioManager.WriteOutput(5, true))
        {
            Console.WriteLine("Output 5 set to true successfully.");
        }

        // 延时1秒后将输出点5设为false
        Thread.Sleep(1000);
        ioManager.WriteOutput(5, false);
    }
    catch (IOException ex)
    {
        Console.WriteLine($"IO error: {ex.Message}");
    }
    finally
    {
        // 关闭IO管理器
        ioManager.Close();
    }
}
else
{
    Console.WriteLine("Failed to initialize IO manager.");
}

7.2 事件处理

// 创建并初始化IO管理器
I_IOManager ioManager = new IOManager();
if (ioManager.Initialize())
{
    // 注册IO状态变化事件处理函数
    ioManager.RegisterIOChangeHandler(10, (ioId, value) => {
        Console.WriteLine($"IO {ioId} changed to: {value}");
    });

    // 注册所有IO点的变化事件（-1表示所有IO点）
    ioManager.RegisterIOChangeHandler(-1, (ioId, value) => {
        Console.WriteLine($"[Global] IO {ioId} changed to: {value}");
    });

    // 执行IO操作
    // ...
}

7.3 批量操作

// 创建并初始化IO管理器
I_IOManager ioManager = new IOManager();
if (ioManager.Initialize())
{
    try
    {
        // 批量读取输入点状态
        List<int> inputIds = new List<int> { 10, 11, 12, 13 };
        Dictionary<int, bool> inputStates = ioManager.ReadInputs(inputIds);

        foreach (var kvp in inputStates)
        {
            Console.WriteLine($"Input {kvp.Key} state: {kvp.Value}");
        }

        // 批量写入输出点状态
        Dictionary<int, bool> outputValues = new Dictionary<int, bool>
        {
            { 1, true },
            { 2, false },
            { 3, true },
            { 4, false }
        };

        if (ioManager.WriteOutputs(outputValues))
        {
            Console.WriteLine("All outputs written successfully.");
        }
    }
    catch (IOException ex)
    {
        Console.WriteLine($"IO batch operation error: {ex.Message}");
    }
    finally
    {
        // 关闭IO管理器
        ioManager.Close();
    }
}

7.4 高级功能

// 创建并初始化IO管理器
I_IOManager ioManager = new IOManager();
if (ioManager.Initialize())
{
    try
    {
        // 设置输出点闪烁（亮500ms，灭500ms，闪烁5次）
        ioManager.BlinkOutput(5, 500, 500, 5);

        // 延时输出（5秒后将输出点6设为true）
        ioManager.DelayedWriteOutput(6, true, 5000);

        Console.WriteLine("Advanced IO functions set up successfully.");
    }
    catch (IOException ex)
    {
        Console.WriteLine($"Advanced IO error: {ex.Message}");
    }
    finally
    {
        // 关闭IO管理器前停止所有闪烁
        ioManager.StopBlinkOutput();
        // 关闭IO管理器
        ioManager.Close();
    }
}

7.5 使用IO监控器

// 创建并初始化IO管理器
I_IOManager ioManager = new IOManager();
if (ioManager.Initialize())
{
    // 创建IO监控器
    IOMonitor ioMonitor = new IOMonitor(ioManager);

    // 注册IO状态变化事件
    ioMonitor.IOStateChanged += (ioId, oldValue, newValue) => {
        Console.WriteLine($"IO {ioId} changed from {oldValue} to {newValue}");
    };

    // 开始监控，扫描间隔为100ms
    ioMonitor.StartMonitoring(100);

    Console.WriteLine("IO monitoring started. Press any key to stop.");
    Console.ReadKey();

    // 停止监控
    ioMonitor.StopMonitoring();

    // 关闭IO管理器
    ioManager.Close();
}

8. 最佳实践

1. 初始化和资源释放：始终确保在使用 IO 管理器后正确关闭它，以释放资源。

2. 错误处理：捕获并处理所有可能的 IO 操作异常，确保系统稳定运行。

3. 批量操作：对于多个 IO 点的操作，优先使用批量操作方法，提高效率。

4. 事件驱动：使用事件机制响应 IO 状态变化，避免频繁轮询。

5. 命名规范：使用有意义的 IO 点名，便于系统维护和故障排查。

6. 配置管理：通过配置文件管理 IO 映射关系，提高系统的可配置性和可维护性。

9. 注意事项

1. IO 操作通常是实时性要求较高的任务，应避免在主线程中频繁执行 IO 操作。

2. 对于需要实时监控的场景，建议使用 IOMonitor 类而不是自行实现轮询逻辑。

3. 批量读写操作比单个操作更高效，特别是在需要同时访问多个 IO 点时。

4. 某些高级功能（如闪烁、延时输出）可能需要占用额外的系统资源，应谨慎使用。

5. 在多线程环境中使用 IO 管理器时，需要注意线程安全问题。