WPF实现数字孪生示例

WPF 数字孪生系统实现示例

数字孪生(Digital Twin)是通过数字化手段在虚拟空间中构建物理实体的精确数字模型，并实现虚实映射、实时交互和智能决策的技术。本文将展示如何使用WPF实现一个基础的数字孪生系统示例。

一、系统架构设计

1. 整体架构

+-------------------+
|     用户界面       |  <-- WPF前端
+-------------------+
          |
          v
+-------------------+
|  业务逻辑层       |  <-- 数字孪生核心逻辑
+-------------------+
          |
          v
+-------------------+
|  数据访问层       |  <-- 物理实体数据源
+-------------------+
          |
          v
+-------------------+
|  物理实体(真实世界)|
+-------------------+

2. 技术选型

前端：WPF (Windows Presentation Foundation)
数据通信：MQTT/HTTP/WebSocket
3D可视化：Helix Toolkit (WPF 3D图形库)
数据存储：SQLite/SQL Server
实时通信：SignalR

二、核心功能模块

1. 数字孪生模型

// DigitalTwinModel.cs
public class DigitalTwinModel
{
    public string Id { get; set; }
    public string Name { get; set; }
    public string Type { get; set; } // 设备类型
    public Dictionary<string, object> Properties { get; set; } = new();
    public List<Sensor> Sensors { get; set; } = new();
    public List<Actuator> Actuators { get; set; } = new();
    public DateTime LastUpdateTime { get; set; }
}

public class Sensor
{
    public string Id { get; set; }
    public string Name { get; set; }
    public string DataType { get; set; } // 温度、湿度等
    public object CurrentValue { get; set; }
    public double MinValue { get; set; }
    public double MaxValue { get; set; }
}

public class Actuator
{
    public string Id { get; set; }
    public string Name { get; set; }
    public string ControlType { get; set; } // 开关、调节等
    public object TargetValue { get; set; }
    public object CurrentValue { get; set; }
}

2. 数据采集模块

// DataCollector.cs
public class DataCollector : IDisposable
{
    private readonly Timer _timer;
    private readonly IDigitalTwinRepository _repository;
    
    public event EventHandler<DigitalTwinDataChangedEventArgs> DataChanged;
    
    public DataCollector(IDigitalTwinRepository repository)
    {
        _repository = repository;
        _timer = new Timer(1000); // 1秒采集一次
        _timer.Elapsed += OnTimerElapsed;
    }
    
    public void Start()
    {
        _timer.Start();
    }
    
    public void Stop()
    {
        _timer.Stop();
    }
    
    private void OnTimerElapsed(object sender, ElapsedEventArgs e)
    {
        try
        {
            var twins = _repository.GetAllDigitalTwins();
            
            foreach (var twin in twins)
            {
                // 模拟数据采集
                var newData = SimulateDataCollection(twin);
                
                // 更新孪生数据
                twin.Properties = newData.Properties;
                twin.Sensors = newData.Sensors;
                twin.LastUpdateTime = DateTime.Now;
                
                // 保存到数据库
                _repository.UpdateDigitalTwin(twin);
                
                // 触发事件
                DataChanged?.Invoke(this, 
                    new DigitalTwinDataChangedEventArgs(twin));
            }
        }
        catch (Exception ex)
        {
            // 错误处理
            LogError(ex);
        }
    }
    
    private DigitalTwinModel SimulateDataCollection(DigitalTwinModel twin)
    {
        // 这里模拟数据采集过程
        // 实际项目中应替换为真实的PLC/传感器数据采集代码
        
        var newData = twin.Clone();
        
        foreach (var sensor in newData.Sensors)
        {
            // 模拟传感器数据变化
            if (sensor.DataType == "Temperature")
            {
                sensor.CurrentValue = 
                    Math.Round(20 + new Random().NextDouble() * 10, 1);
            }
            else if (sensor.DataType == "Humidity")
            {
                sensor.CurrentValue = 
                    Math.Round(40 + new Random().NextDouble() * 40, 1);
            }
        }
        
        return newData;
    }
    
    public void Dispose()
    {
        _timer?.Dispose();
    }
}

3. 3D可视化模块

// DigitalTwin3DViewer.xaml.cs
using HelixToolkit.Wpf;
using System.Windows.Media.Media3D;

public partial class DigitalTwin3DViewer : UserControl
{
    public static readonly DependencyProperty DigitalTwinProperty =
        DependencyProperty.Register("DigitalTwin", typeof(DigitalTwinModel), 
        typeof(DigitalTwin3DViewer), new PropertyMetadata(null, OnDigitalTwinChanged));
    
    private readonly HelixViewport3D _viewport;
    private readonly Model3DGroup _rootModel;
    
    public DigitalTwinModel DigitalTwin
    {
        get => (DigitalTwinModel)GetValue(DigitalTwinProperty);
        set => SetValue(DigitalTwinProperty, value);
    }
    
    public DigitalTwin3DViewer()
    {
        InitializeComponent();
        
        _viewport = new HelixViewport3D();
        _rootModel = new Model3DGroup();
        
        // 添加默认相机
        _viewport.Camera = new PerspectiveCamera
        {
            Position = new Point3D(0, 0, 10),
            LookDirection = new Vector3D(0, 0, -10),
            UpDirection = new Vector3D(0, 1, 0),
            FieldOfView = 60
        };
        
        // 添加默认光源
        _viewport.Children.Add(new DefaultLights());
        
        this.Content = _viewport;
    }
    
    private static void OnDigitalTwinChanged(DependencyObject d, 
        DependencyPropertyChangedEventArgs e)
    {
        var viewer = (DigitalTwin3DViewer)d;
        viewer.Update3DModel();
    }
    
    private void Update3DModel()
    {
        if (DigitalTwin == null) return;
        
        _rootModel.Children.Clear();
        
        // 根据孪生数据创建3D模型
        CreateBaseModel();
        UpdateSensors();
        UpdateActuators();
        
        _viewport.Children.Clear();
        _viewport.Children.Add(new ModelVisual3D { Content = _rootModel });
    }
    
    private void CreateBaseModel()
    {
        // 创建设备基础模型
        var deviceMaterial = new DiffuseMaterial(new SolidColorBrush(Colors.Gray));
        
        // 根据类型创建不同形状
        switch (DigitalTwin.Type)
        {
            case "Pump":
                var pump = CreateCylinder(1, 2, deviceMaterial);
                SetTransform(pump, new Vector3D(0, 0, 0));
                _rootModel.Children.Add(pump);
                break;
            case "Valve":
                var valve = CreateCylinder(0.5, 1, deviceMaterial);
                SetTransform(valve, new Vector3D(0, 0, 0));
                _rootModel.Children.Add(valve);
                break;
            // 其他设备类型...
        }
    }
    
    private void UpdateSensors()
    {
        foreach (var sensor in DigitalTwin.Sensors)
        {
            var sensorMaterial = new DiffuseMaterial(
                sensor.DataType switch
                {
                    "Temperature" => new SolidColorBrush(Colors.Red),
                    "Humidity" => new SolidColorBrush(Colors.Blue),
                    _ => new SolidColorBrush(Colors.Green)
                });
            
            var sensorModel = CreateSphere(0.1, sensorMaterial);
            SetTransform(sensorModel, GetSensorPosition(sensor.Id));
            
            // 添加传感器值显示
            var text = new TextBlock
            {
                Text = $"{sensor.CurrentValue} {sensor.DataType}",
                Foreground = Brushes.White,
                FontSize = 8
            };
            
            var textVisual = new ScreenSpaceLines3D();
            // 实际项目中应使用HelixToolkit的文本渲染功能
            
            _rootModel.Children.Add(sensorModel);
        }
    }
    
    private void UpdateActuators()
    {
        foreach (var actuator in DigitalTwin.Actuators)
        {
            var actuatorMaterial = new DiffuseMaterial(
                actuator.ControlType switch
                {
                    "OnOff" => new SolidColorBrush(Colors.Yellow),
                    "Adjustable" => new SolidColorBrush(Colors.Cyan),
                    _ => new SolidColorBrush(Colors.White)
                });
            
            var actuatorModel = CreateCube(0.2, actuatorMaterial);
            SetTransform(actuatorModel, GetActuatorPosition(actuator.Id));
            
            _rootModel.Children.Add(actuatorModel);
        }
    }
    
    // 辅助方法...
    private Model3D CreateCylinder(double diameter, double height, Material material)
    {
        // 创建圆柱体
        var cylinder = new CylinderVisual3D
        {
            Diameter = diameter,
            Height = height,
            Material = material,
            BackMaterial = material
        };
        
        return cylinder.Content;
    }
    
    private Model3D CreateSphere(double radius, Material material)
    {
        // 创建球体
        var sphere = new SphereVisual3D
        {
            Radius = radius,
            Material = material,
            BackMaterial = material
        };
        
        return sphere.Content;
    }
    
    private Model3D CreateCube(double size, Material material)
    {
        // 创建立方体
        var cube = new BoxVisual3D
        {
            Width = size,
            Height = size,
            Depth = size,
            Material = material,
            BackMaterial = material
        };
        
        return cube.Content;
    }
    
    private void SetTransform(Model3D model, Vector3D position)
    {
        // 设置模型变换
        var transform = new TranslateTransform3D(position);
        model.Transform = transform;
    }
    
    private Vector3D GetSensorPosition(string sensorId)
    {
        // 根据传感器ID返回位置
        // 实际项目中应从设备模型中获取
        return new Vector3D(0, 0, 1);
    }
    
    private Vector3D GetActuatorPosition(string actuatorId)
    {
        // 根据执行器ID返回位置
        // 实际项目中应从设备模型中获取
        return new Vector3D(0, 0, -1);
    }
}

4. 数据绑定与交互

<!-- MainWindow.xaml -->
<Window x:Class="DigitalTwinDemo.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:DigitalTwinDemo"
        mc:Ignorable="d"
        Title="数字孪生系统" Height="600" Width="800">
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="3*"/>
            <ColumnDefinition Width="2*"/>
        </Grid.ColumnDefinitions>
        
        <!-- 3D视图区域 -->
        <local:DigitalTwin3DViewer x:Name="TwinViewer" Grid.Column="0"/>
        
        <!-- 控制面板 -->
        <StackPanel Grid.Column="1" Margin="10">
            <TextBlock Text="设备状态" FontSize="16" FontWeight="Bold"/>
            
            <StackPanel Orientation="Horizontal" Margin="0,5">
                <TextBlock Text="设备名称:" Width="80"/>
                <TextBox Text="{Binding DigitalTwin.Name, ElementName=TwinViewer}" Width="150"/>
            </StackPanel>
            
            <StackPanel Orientation="Horizontal" Margin="0,5">
                <TextBlock Text="设备类型:" Width="80"/>
                <ComboBox ItemsSource="{Binding AvailableTypes}" 
                          SelectedItem="{Binding DigitalTwin.Type, ElementName=TwinViewer}"/>
            </StackPanel>
            
            <Separator Margin="0,10"/>
            
            <TextBlock Text="传感器数据" FontSize="16" FontWeight="Bold"/>
            
            <ItemsControl ItemsSource="{Binding DigitalTwin.Sensors, ElementName=TwinViewer}">
                <ItemsControl.ItemTemplate>
                    <DataTemplate>
                        <StackPanel Orientation="Horizontal" Margin="0,2">
                            <TextBlock Text="{Binding Name}" Width="100"/>
                            <TextBlock Text="{Binding CurrentValue}" Width="80"/>
                            <TextBlock Text="{Binding DataType}" Width="80"/>
                        </StackPanel>
                    </DataTemplate>
                </ItemsControl.ItemTemplate>
            </ItemsControl>
            
            <Separator Margin="0,10"/>
            
            <Button Content="刷新3D模型" Click="Refresh3DModel_Click" Margin="0,10"/>
        </StackPanel>
    </Grid>
</Window>

// MainWindow.xaml.cs
public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        
        // 初始化ViewModel
        var viewModel = new MainViewModel();
        DataContext = viewModel;
        
        // 模拟数据更新
        var collector = new DataCollector(viewModel.Repository);
        collector.DataChanged += (s, e) => 
        {
            // 更新UI
            viewModel.DigitalTwin = e.Twin;
        };
        collector.Start();
    }
    
    private void Refresh3DModel_Click(object sender, RoutedEventArgs e)
    {
        // 强制刷新3D视图
        TwinViewer.Update3DModel();
    }
}

三、核心功能实现

1. 数字孪生模型同步

// DigitalTwinSyncService.cs
public class DigitalTwinSyncService
{
    private readonly IDigitalTwinRepository _repository;
    private readonly Dictionary<string, DigitalTwinModel> _localCache = new();
    
    public DigitalTwinSyncService(IDigitalTwinRepository repository)
    {
        _repository = repository;
    }
    
    public async Task SyncWithPhysicalEntityAsync(string twinId)
    {
        // 从物理实体获取最新数据
        var physicalData = await GetPhysicalEntityDataAsync(twinId);
        
        // 获取本地孪生模型
        if (!_localCache.TryGetValue(twinId, out var twinModel))
        {
            twinModel = await _repository.GetDigitalTwinAsync(twinId);
            _localCache[twinId] = twinModel;
        }
        
        // 同步数据
        twinModel.Properties = physicalData.Properties;
        twinModel.Sensors = physicalData.Sensors;
        twinModel.Actuators = physicalData.Actuators;
        twinModel.LastUpdateTime = DateTime.Now;
        
        // 更新本地缓存和数据库
        _localCache[twinId] = twinModel;
        await _repository.UpdateDigitalTwinAsync(twinModel);
    }
    
    private async Task<PhysicalEntityData> GetPhysicalEntityDataAsync(string entityId)
    {
        // 实际项目中应实现与物理实体的通信
        // 这里模拟数据获取
        await Task.Delay(100); // 模拟网络延迟
        
        return new PhysicalEntityData
        {
            Properties = new Dictionary<string, object>
            {
                ["Location"] = "Factory Floor 1",
                ["Status"] = "Running"
            },
            Sensors = new List<SensorData>
            {
                new SensorData { Id = "S1", DataType = "Temperature", Value = 25.3 },
                new SensorData { Id = "S2", DataType = "Humidity", Value = 45.7 }
            },
            Actuators = new List<ActuatorData>
            {
                new ActuatorData { Id = "A1", ControlType = "OnOff", Value = true }
            }
        };
    }
}

2. 实时数据可视化

// RealTimeDataVisualizer.cs
public class RealTimeDataVisualizer : IDisposable
{
    private readonly DigitalTwin3DViewer _viewer;
    private readonly SubscriptionToken _token;
    
    public RealTimeDataVisualizer(DigitalTwin3DViewer viewer)
    {
        _viewer = viewer;
        
        // 订阅数据变化事件
        _token = EventAggregator.Subscribe<DigitalTwinDataChangedEventArgs>(OnDataChanged);
    }
    
    private void OnDataChanged(DigitalTwinDataChangedEventArgs args)
    {
        // 在UI线程更新3D视图
        Application.Current.Dispatcher.Invoke(() =>
        {
            _viewer.DigitalTwin = args.Twin;
            _viewer.Update3DModel();
        });
    }
    
    public void Dispose()
    {
        EventAggregator.Unsubscribe(_token);
    }
}

3. 设备控制功能

// DeviceController.cs
public class DeviceController
{
    private readonly IDigitalTwinRepository _repository;
    private readonly IPhysicalDeviceCommunicator _communicator;
    
    public DeviceController(IDigitalTwinRepository repository, 
                          IPhysicalDeviceCommunicator communicator)
    {
        _repository = repository;
        _communicator = communicator;
    }
    
    public async Task ControlActuatorAsync(string twinId, string actuatorId, object value)
    {
        // 获取孪生模型
        var twin = await _repository.GetDigitalTwinAsync(twinId);
        
        // 查找执行器
        var actuator = twin.Actuators.FirstOrDefault(a => a.Id == actuatorId);
        if (actuator == null)
        {
            throw new ArgumentException($"执行器 {actuatorId} 不存在");
        }
        
        // 验证值
        if (!IsValidValue(actuator, value))
        {
            throw new ArgumentException($"无效的值 {value} 对于执行器 {actuatorId}");
        }
        
        // 更新孪生模型
        actuator.CurrentValue = value;
        actuator.TargetValue = value;
        twin.LastUpdateTime = DateTime.Now;
        
        await _repository.UpdateDigitalTwinAsync(twin);
        
        // 发送控制命令到物理设备
        await _communicator.SendControlCommandAsync(twinId, actuatorId, value);
    }
    
    private bool IsValidValue(Actuator actuator, object value)
    {
        // 根据执行器类型验证值
        switch (actuator.ControlType)
        {
            case "OnOff":
                return value is bool;
            case "Adjustable":
                return value is double || value is int;
            default:
                return true;
        }
    }
}

四、完整示例项目结构

DigitalTwinDemo/
├── Models/                  # 数据模型
│   ├── DigitalTwinModel.cs  
│   ├── Sensor.cs
│   └── Actuator.cs
├── Services/                # 服务层
│   ├── DataCollector.cs
│   ├── DigitalTwinSyncService.cs
│   └── DeviceController.cs
├── Repositories/            # 数据访问
│   ├── IDigitalTwinRepository.cs
│   └── DigitalTwinRepository.cs
├── ViewModels/              # 视图模型
│   ├── MainViewModel.cs
│   └── DigitalTwinViewModel.cs
├── Views/                   # 视图
│   ├── MainWindow.xaml
│   └── DigitalTwin3DViewer.xaml
├── Helpers/                 # 辅助类
│   ├── EventAggregator.cs
│   └── Logger.cs
└── App.xaml.cs              # 应用程序入口

五、关键技术点

3D可视化：使用HelixToolkit实现设备模型的3D展示
数据绑定：WPF的双向数据绑定机制实现UI与数据的同步
实时更新：通过事件聚合器实现数据变化时的UI自动更新
设备通信：模拟与物理设备的通信协议（实际项目中替换为真实协议）
MVVM模式：分离视图与逻辑，提高代码可维护性