C# + WPF 打造半导体晶圆与石墨岛搬移：从 HMI 到运动控制的工程实践

public enum WaferState { Idle, Aligning, Transferring, Processing, Error }

public class Wafer
{
    public string Id { get; set; }
    public int Slot { get; set; }          // 石墨岛上的槽位
    public WaferState State { get; set; }
    public bool IsPresent { get; set; }
}

public class GraphiteIsland
{
    public string Id { get; set; }
    public int Capacity { get; set; }
    public List<Wafer> Wafers { get; set; } = new();
}

public enum TransferStep
{
    Idle, SafetyCheck, PickFromCassette, Align,
    PlaceToIsland, Verify, Done, Error
}

public class TransferSequencer
{
    private readonly IRobotService _robot;
    private readonly IAlignerService _aligner;
    private readonly ISafetyInterlock _safety;
    private readonly ILogger _log;

    public TransferStep Current { get; private set; } = TransferStep.Idle;

    public async Task RunAsync(Wafer wafer, GraphiteIsland island,
                               CancellationToken ct)
    {
        try
        {
            Current = TransferStep.SafetyCheck;
            await _safety.EnsureSafeAsync(ct);

            Current = TransferStep.PickFromCassette;
            await _robot.PickAsync(wafer.Slot, ct);
            _log.Info($"取片 {wafer.Id} 槽位 {wafer.Slot}");

            Current = TransferStep.Align;
            var offset = await _aligner.AlignAsync(ct);
            if (Math.Abs(offset.X) > 0.1 || Math.Abs(offset.Y) > 0.1)
                throw new InvalidOperationException("寻边偏差超限");

            Current = TransferStep.PlaceToIsland;
            await _robot.PlaceAsync(island.Id, wafer.Slot, ct);

            Current = TransferStep.Verify;
            if (!await _robot.CheckPresenceAsync(island.Id, wafer.Slot, ct))
                throw new InvalidOperationException("放片校验失败");

            wafer.State = WaferState.Processing;
            Current = TransferStep.Done;
        }
        catch (OperationCanceledException)
        {
            _log.Warn("搬移被取消，执行回退");
            await _robot.RetractAsync(CancellationToken.None);
            Current = TransferStep.Idle;
            throw;
        }
        catch (Exception ex)
        {
            _log.Error(ex, "搬移失败");
            Current = TransferStep.Error;
            throw;
        }
    }
}

public class SerialRobotService : IRobotService
{
    private readonly SerialPort _port;
    private readonly SemaphoreSlim _lock = new(1, 1);

    public SerialRobotService(string portName)
    {
        _port = new SerialPort(portName, 115200)
        {
            ReadTimeout = 2000,
            WriteTimeout = 2000
        };
        _port.Open();
    }

    private async Task<string> SendAsync(string cmd, CancellationToken ct)
    {
        await _lock.WaitAsync(ct);
        try
        {
            _port.WriteLine(cmd);
            await Task.Delay(50, ct);
            return _port.ReadLine();
        }
        finally { _lock.Release(); }
    }

    public async Task PickAsync(int slot, CancellationToken ct)
    {
        var resp = await SendAsync($"PICK {slot}", ct);
        if (!resp.StartsWith("OK")) throw new IOException(resp);
    }

    public async Task PlaceAsync(string island, int slot, CancellationToken ct)
    {
        var resp = await SendAsync($"PLACE {island} {slot}", ct);
        if (!resp.StartsWith("OK")) throw new IOException(resp);
    }

    public async Task<bool> CheckPresenceAsync(string island, int slot, CancellationToken ct)
        => (await SendAsync($"SENSOR {island} {slot}", ct)).Trim() == "1";

    public async Task RetractAsync(CancellationToken ct)
        => await SendAsync("RETRACT", ct);
}

public class MainViewModel : INotifyPropertyChanged
{
    private readonly TransferSequencer _seq;
    private CancellationTokenSource? _cts;

    public ObservableCollection<Wafer> Wafers { get; } = new();
    public string Status { get; private set; } = "就绪";

    public ICommand StartTransferCommand { get; }
    public ICommand AbortCommand { get; }

    public MainViewModel(TransferSequencer seq)
    {
        _seq = seq;
        StartTransferCommand = new RelayCommand(async _ => await StartAsync());
        AbortCommand = new RelayCommand(_ => _cts?.Cancel());
    }

    private async Task StartAsync()
    {
        _cts = new CancellationTokenSource();
        foreach (var wafer in Wafers.Where(w => w.IsPresent))
        {
            Status = $"搬移 {wafer.Id}：{_seq.Current}";
            await _seq.RunAsync(wafer, new GraphiteIsland { Id = "G1" }, _cts.Token);
        }
        Status = "完成";
    }
}

<StackPanel>
    <TextBlock Text="{Binding Status}" FontSize="16"/>
    <ItemsControl ItemsSource="{Binding Wafers}">
        <ItemsControl.ItemTemplate>
            <DataTemplate>
                <TextBlock Text="{Binding Id, StringFormat=晶圆 {0}}"/>
            </DataTemplate>
        </ItemsControl.ItemTemplate>
    </ItemsControl>
    <Button Content="开始搬移" Command="{Binding StartTransferCommand}"/>
    <Button Content="中止" Command="{Binding AbortCommand}"/>
</StackPanel>