C# + WPF 打造半导体晶圆与石墨岛搬移上位机：从架构设计到工程落地

UI层：WPF + MVVM（CommunityToolkit.Mvvm / Prism）
通信层：S7.Net（西门子）、HslCommunication、Modbus
运动控制：固高/雷赛/ACS 的 .NET SDK
视觉：Halcon/.NET、OpenCvSharp
数据：SQLite（本地）/ SQL Server（MES对接）
日志：Serilog / NLog
DI容器：Microsoft.Extensions.DependencyInjection

┌─────────────────────────────────────┐
│         Presentation (WPF)          │
│   Views / ViewModels / Converters   │
├─────────────────────────────────────┤
│         Application Layer           │
│   流程编排 / 任务调度 / 状态机       │
├─────────────────────────────────────┤
│         Domain Layer                │
│   设备模型 / 搬移任务 / 报警规则     │
├─────────────────────────────────────┤
│       Infrastructure Layer          │
│  PLC通信 / 运动控制 / 数据库 / 日志  │
└─────────────────────────────────────┘

var machine = new StateMachine<State, Trigger>(State.Idle);

machine.Configure(State.Idle)
    .Permit(Trigger.StartTransfer, State.Picking);

machine.Configure(State.Picking)
    .Permit(Trigger.PickDone, State.Placing)
    .Permit(Trigger.Error, State.Fault);

machine.Configure(State.Placing)
    .Permit(Trigger.PlaceDone, State.Idle)
    .Permit(Trigger.Error, State.Fault);

public interface IPlcService
{
    Task<bool> ConnectAsync(string ip, int rack, int slot);
    Task<short> ReadIntAsync(string address);
    Task WriteBoolAsync(string address, bool value);
    Task<bool> WaitForSignalAsync(string address, bool expected, int timeoutMs);
}

public class S7PlcService : IPlcService
{
    private Plc _plc;

    public async Task<bool> ConnectAsync(string ip, int rack, int slot)
    {
        _plc = new Plc(CpuType.S71200, ip, rack, slot);
        await _plc.OpenAsync();
        return _plc.IsConnected;
    }

    public async Task<bool> WaitForSignalAsync(string address, bool expected, int timeoutMs)
    {
        var sw = Stopwatch.StartNew();
        while (sw.ElapsedMilliseconds < timeoutMs)
        {
            var val = await _plc.ReadAsync(address);
            if ((bool)val == expected) return true;
            await Task.Delay(10);
        }
        return false;
    }
}

public interface IMotionService
{
    Task MoveAbsoluteAsync(int axis, double position, double speed);
    Task MoveRelativeAsync(int axis, double distance, double speed);
    Task HomeAsync(int axis);
    double GetPosition(int axis);
    bool IsInPosition(int axis, double target, double tolerance);
}

{
  "PickPosition": { "X": 120.5, "Y": 80.2, "Z": 10.0, "R": 0 },
  "PlacePosition": { "X": 300.0, "Y": 150.0, "Z": 5.0, "R": 90 }
}

public interface IVisionService
{
    Task<VisionResult> LocateWaferAsync();
}

public record VisionResult(double OffsetX, double OffsetY, double OffsetTheta, bool Success);

public async Task<bool> TransferWaferAsync(CancellationToken ct)
{
    try
    {
        await _stateMachine.FireAsync(Trigger.StartTransfer);

        // 1. 检查安全条件
        if (!await _safetyService.CheckSafeAsync())
            throw new SafetyException("安全条件不满足");

        // 2. 移动到取片位
        await _motionService.MoveAbsoluteAsync(Axis.Z, _points.SafeZ, 50);
        await _motionService.MoveAbsoluteAsync(Axis.X, _points.PickX, 100);
        await _motionService.MoveAbsoluteAsync(Axis.Y, _points.PickY, 100);

        // 3. 真空吸取
        await _ioService.SetVacuumAsync(true);
        if (!await _ioService.WaitVacuumAsync(true, 2000))
            throw new VacuumException("真空建立失败");

        // 4. 视觉定位
        var vision = await _visionService.LocateWaferAsync();
        if (!vision.Success) throw new VisionException("视觉定位失败");

        // 5. 移动到放片位（含补偿）
        await _motionService.MoveAbsoluteAsync(Axis.X, _points.PlaceX + vision.OffsetX, 100);
        await _motionService.MoveAbsoluteAsync(Axis.Y, _points.PlaceY + vision.OffsetY, 100);
        await _motionService.MoveAbsoluteAsync(Axis.Z, _points.PlaceZ, 20);

        // 6. 释放真空
        await _ioService.SetVacuumAsync(false);
        await _ioService.WaitVacuumAsync(false, 2000);

        // 7. 复位
        await _motionService.MoveAbsoluteAsync(Axis.Z, _points.SafeZ, 50);

        await _stateMachine.FireAsync(Trigger.PlaceDone);
        await _traceService.RecordAsync(new TransferRecord { /* ... */ });

        return true;
    }
    catch (Exception ex)
    {
        await _stateMachine.FireAsync(Trigger.Error);
        _logger.Error(ex, "搬移失败");
        await _alarmService.RaiseAsync(ex);
        return false;
    }
}

public class TransferRecord
{
    public long Id { get; set; }
    public string WaferId { get; set; }
    public string CassetteId { get; set; }
    public int SlotIndex { get; set; }
    public DateTime StartTime { get; set; }
    public DateTime EndTime { get; set; }
    public bool Success { get; set; }
    public double OffsetX { get; set; }
    public double OffsetY { get; set; }
    public string Operator { get; set; }
}

Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .WriteTo.Console()
    .WriteTo.File("logs/app-.log", rollingInterval: RollingInterval.Day)
    .WriteTo.SQLite("logs/logs.db")
    .CreateLogger();

<Canvas>
    <Rectangle Width="40" Height="40" Fill="Gray"
               Canvas.Left="{Binding RobotX}"
               Canvas.Top="{Binding RobotY}"/>
    <Ellipse Width="200" Height="200" Stroke="Blue"
             Canvas.Left="{Binding WaferX}"
             Canvas.Top="{Binding WaferY}"/>
</Canvas>

<ResourceDictionary>
    <SolidColorBrush x:Key="BackgroundBrush" Color="#1E1E1E"/>
    <SolidColorBrush x:Key="PanelBrush" Color="#252526"/>
    <SolidColorBrush x:Key="AccentBrush" Color="#007ACC"/>
    <SolidColorBrush x:Key="AlarmBrush" Color="#F44747"/>
</ResourceDictionary>

public class MockPlcService : IPlcService
{
    private readonly Dictionary<string, object> _memory = new();

    public Task<short> ReadIntAsync(string address)
        => Task.FromResult((short)(_memory.GetValueOrDefault(address) ?? (short)0));

    public Task WriteBoolAsync(string address, bool value)
    {
        _memory[address] = value;
        return Task.CompletedTask;
    }
}