ASTM-D7896-19TransientHot-Wire-Method/ViewModels/D7896ViewModel.cs

using ASTM_D7896_Tester.Helpers;
using ASTM_D7896_Tester.Models;
using ASTM_D7896_Tester.Services;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using OxyPlot;
using OxyPlot.Axes;
using OxyPlot.Series;
using System;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;

namespace ASTM_D7896_Tester.ViewModels;

public partial class D7896ViewModel : ObservableObject
{
    private readonly IPlcService _plcService;
    private AppConfig _config;
    private readonly ReportService _reportService;

    // 电压表服务
    private Th1963LanService _th1963Ustd;   // 6位半测量标准电阻电压 U_std
    private FiveHalfDmmService _fiveHalfUpt; // 5位半测量铂丝电压 U_pt

    private CancellationTokenSource _testCts; // 用于停止测试
    private bool _stopRequested;

    // 后台监控定时器
    private Timer? _monitorTimer;

    // 常量: 标准电阻值 1Ω
    private const double StandardResistor = 1.0;

    // 铂丝电阻温度系数 (纯铂)
    private const double AlphaPt = 0.00385; // /°C

    // 加热功率 Q 计算相关
    private double _heatingCurrent;   // 实际加热电流平均值
    private double _wireResistanceAvg; // 铂丝平均电阻

    // 温升曲线数据
    [ObservableProperty] private string _curveTitle = "温升曲线";
    [ObservableProperty] private PlotModel _temperatureCurveModel;

    // UI 绑定属性 (与之前一致)
    public ObservableCollection<string> ReferenceLiquids { get; } = new() { "蒸馏水", "甲苯", "乙二醇" };
    [ObservableProperty] private string _sampleId = "未命名样品";
    [ObservableProperty] private double _testTemperature = 25.0;
    [ObservableProperty] private string _testDateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
    [ObservableProperty] private bool _isTesting = false;
    [ObservableProperty] private string _statusMessage = "就绪";
    [ObservableProperty] private int _currentMeasurementIndex = 0;
    [ObservableProperty] private ObservableCollection<MeasurementResult> _measurements = new();
    [ObservableProperty] private double _averageThermalConductivity;
    [ObservableProperty] private double _averageThermalDiffusivity;
    [ObservableProperty] private double _averageVolumetricHeatCapacity;

    [ObservableProperty] private double _sampleVolume = 40.0;
    [ObservableProperty] private bool _bubbleRemoved = true;
    [ObservableProperty] private bool _usePressure = false;
    [ObservableProperty] private double _pressureValue = 0.0;
    [ObservableProperty] private bool _isCleanConfirmed = true;
    [ObservableProperty] private string _cleanerName = "";
    [ObservableProperty] private double _ambientTemperature = 25.0;
    [ObservableProperty] private bool _ambientCalibrated = true;
    [ObservableProperty] private bool _platinumCompatible = true;
    [ObservableProperty] private string _liquidReactivityNote = "";

    [ObservableProperty] private double _platinumResistance = 0.0;
    [ObservableProperty] private double _chamberPressure = 0.0;
    [ObservableProperty] private double _currentTestTemperature = 0.0;

    [ObservableProperty] private bool _isCalibrating = false;
    [ObservableProperty] private string _calibrationStatus = "";
    [ObservableProperty] private string _selectedReferenceLiquid = "蒸馏水";
    [ObservableProperty] private double _referenceConductivity = 0.606;
    [ObservableProperty] private double _measuredConductivity = 0.0;
    [ObservableProperty] private double _calibrationErrorPercent = 0.0;

    // 实时电压显示（可选）
    [ObservableProperty] private double _platinumVoltage;
    [ObservableProperty] private double _standardResistorVoltage;



    [ObservableProperty] private double _sampleDensity = 1000.0;   // 新增，密度默认值1000 kg/m³（水）

    public D7896ViewModel()
    {
        _config = App.PlcConfig ?? new AppConfig();
        _plcService = App.PlcService;
        _reportService = new ReportService(_config.TestParameters.ReportOutputPath);

        SampleVolume = _config.TestParameters.DefaultSampleVolume;
        UsePressure = _config.TestParameters.UsePressure;
        PressureValue = _config.TestParameters.DefaultPressure;
        SelectedReferenceLiquid = _config.TestParameters.ReferenceLiquid;
        ReferenceConductivity = _config.TestParameters.ReferenceConductivity;

        IsCleanConfirmed = true;
        BubbleRemoved = true;
        PlatinumCompatible = true;
        AmbientCalibrated = true;

        // 初始化电压表服务
        // TH1963 IP 地址需要根据实际配置修改，建议从配置文件读取
        _th1963Ustd = new Th1963LanService();
        // 5位半万用表串口名，例如 "COM3"
        _fiveHalfUpt = new FiveHalfDmmService("COM6", 115200);

        StartBackgroundMonitoring();
    }

    private async void StartBackgroundMonitoring()
    {
        await Task.Delay(1000);
        _monitorTimer = new Timer(async _ => await MonitorPlcValues(), null, 0, 1000);
    }

    private async Task MonitorPlcValues()
    {
        if (!await _plcService.IsConnectedAsync()) return;
        try
        {
            float rawResistance = await _plcService.ReadFloatAsync(_config.PlcRegisterAddresses.Resistance);
            double newResistance = rawResistance;
            Application.Current.Dispatcher.Invoke(() => PlatinumResistance = newResistance);

            float rawPressure = await _plcService.ReadFloatAsync(_config.PlcRegisterAddresses.Pressure);
            Application.Current.Dispatcher.Invoke(() => ChamberPressure = rawPressure);

            float rawTemp = await _plcService.ReadFloatAsync(_config.PlcRegisterAddresses.Temperature);
            Application.Current.Dispatcher.Invoke(() => CurrentTestTemperature = rawTemp);
        }
        catch { }
    }

    private async Task<double> GetInitialResistanceAsync()
    {
        if (!await _plcService.IsConnectedAsync()) return 0;
        try
        {
            float rawResistance = await _plcService.ReadFloatAsync(_config.PlcRegisterAddresses.Resistance);
            return rawResistance / 1000.0;
        }
        catch { return 0; }
    }

    [RelayCommand]
    private async Task StartTestAsync()
    {
        if (IsTesting)
        {
            MessageBox.Show("测试正在进行中", "提示");
            return;
        }

        // 前置检查
        if (!IsCleanConfirmed || !BubbleRemoved || !PlatinumCompatible || !AmbientCalibrated)
        {
            MessageBox.Show("请完成所有测试前确认项", "前置条件未满足");
            return;
        }
        if (SampleVolume <= 0)
        {
            MessageBox.Show("请输入有效的样品量", "参数错误");
            return;
        }
        if (UsePressure && PressureValue <= 0)
        {
            MessageBox.Show("请设置有效的加压值", "参数错误");
            return;
        }

        // 连接PLC和电压表
        if (!await _plcService.IsConnectedAsync())
        {
            if (!await _plcService.ConnectAsync())
            {
                MessageBox.Show("无法连接到PLC", "错误");
                return;
            }
        }

        try
        {
            if (!_fiveHalfUpt.IsOpen) _fiveHalfUpt.Open();
            await _th1963Ustd.ConnectAsync("192.168.1.12", 45454); // 改为实际IP
            await _th1963Ustd.ConfigureForHighSpeedDcvAsync();
            await _fiveHalfUpt.ConfigureHighSpeedDcvAsync();
        }
        catch (Exception ex)
        {
            MessageBox.Show($"电压表连接失败: {ex.Message}", "错误");
            return;
        }

        if (UsePressure)
        {
            StatusMessage = "正在加压...";
            await _plcService.WriteCoilAsync(_config.PlcRegisterAddresses.InletValveCoil, true);
            await Task.Delay(3000);
            await UpdateRealTimeParametersAsync();
            if (ChamberPressure < PressureValue - 5)
                MessageBox.Show($"压力未达到设定值 {PressureValue} kPa", "警告");
        }

        double initialResistance = await GetInitialResistanceAsync();
        if (initialResistance > 0)
            StatusMessage = $"初始电阻: {initialResistance:F4} Ω";

        Measurements.Clear();
        IsTesting = true;
        _stopRequested = false;
        _testCts = new CancellationTokenSource();

        try
        {
            for (int i = 1; i <= _config.TestParameters.MeasurementCount; i++)
            {
                if (_stopRequested) break;

                CurrentMeasurementIndex = i;
                StatusMessage = $"正在执行第 {i} 次测量...";

                // 准备批量采集参数（每通道采样点数，采样率1000点/秒，加热时间1秒 -> 1000点）
                int samples = 1000; // 1秒 * 1000点/秒

                // 预配置两台表：进入等待触发状态
                await _th1963Ustd.PrepareBatchAsync(samples);
                await _fiveHalfUpt.PrepareBatchAsync(samples); // 需要在FiveHalfDmmService中实现PrepareBatchAsync，见补充

                // 启动加热脉冲 (PLC)
                await _plcService.WriteCoilAsync(_config.PlcRegisterAddresses.StartCommand, true);
                // 同时发送触发信号给两台电压表
                await Task.WhenAll(_th1963Ustd.TriggerAsync(), _fiveHalfUpt.TriggerAsync());

                // 等待加热脉冲持续1秒
                await Task.Delay(1);

                // 停止加热
                await _plcService.WriteCoilAsync(_config.PlcRegisterAddresses.StartCommand, false);

                // 等待采集完成（留出额外时间）
                await Task.Delay(500);

                // 获取采集数据
                double[] ustd = await _th1963Ustd.FetchBatchAsync();
                double[] upt = await _fiveHalfUpt.FetchBatchAsync();
                StandardResistorVoltage = ustd.Average();


                // 构建时间数组（假设采样时间正好1秒，采样点数 = ustd.Length）
                double[] timeArray = new double[ustd.Length];
                for (int idx = 0; idx < timeArray.Length; idx++)
                {
                    timeArray[idx] = idx / (double)samples; // 0 ~ 1 秒
                }
                // 计算本次测量的 λ 和 α
                var (lambda, alpha, deltaT, coolingPoints) = ComputeThermalProperties(upt, ustd, timeArray, initialResistance, CurrentTestTemperature);

                // 生成温升曲线图
                GenerateTemperatureCurveFromData(timeArray, deltaT, coolingPoints);

                var result = new MeasurementResult
                {
                    Index = i,
                    ThermalConductivity = lambda,
                    ThermalDiffusivity = alpha
                };
                //result.CalculateVhc();
                result.CalculateVhcAndCp(SampleDensity);
                Application.Current.Dispatcher.Invoke(() => Measurements.Add(result));
                StatusMessage = $"第 {i} 次测量完成，λ={lambda:F4} W/m·K";

                if (i < _config.TestParameters.MeasurementCount && !_stopRequested)
                    await Task.Delay(_config.TestParameters.IntervalSeconds * 1000);
            }

            CalculateAverages();
            StatusMessage = _stopRequested ? "测试已停止。" : "测试完成。";
        }
        catch (Exception ex)
        {
            StatusMessage = $"测试出错: {ex.Message}";
            MessageBox.Show($"测试过程中发生错误: {ex.Message}", "错误");
        }
        finally
        {
            // 停止加热，泄压
            await _plcService.WriteCoilAsync(_config.PlcRegisterAddresses.StartCommand, false);
            if (UsePressure)
            {
                await _plcService.WriteCoilAsync(_config.PlcRegisterAddresses.InletValveCoil, false);
                await _plcService.WriteCoilAsync(_config.PlcRegisterAddresses.OutletValveCoil, true);
                await Task.Delay(1000);
                await _plcService.WriteCoilAsync(_config.PlcRegisterAddresses.OutletValveCoil, false);
            }
            IsTesting = false;
            _fiveHalfUpt.Close();
            _th1963Ustd.Dispose();
            _testCts?.Dispose();
        }
    }

    /// <summary>
    /// 根据采集到的电压序列计算热导率 λ、热扩散率 α、温升数组以及冷却曲线数据点
    /// </summary>
    private (double lambda, double alpha, double[] deltaT, List<DataPoint> coolingPoints) ComputeThermalProperties(
        double[] upt, double[] ustd, double[] time, double initialResistance, double bathTemp)
    {
        int n = Math.Min(upt.Length, ustd.Length);
        double[] current = new double[n];
        double[] ptResistance = new double[n];
        double[] deltaT = new double[n];

        // 1. 计算电流、铂丝电阻和温升
        for (int i = 0; i < n; i++)
        {
            current[i] = ustd[i] / StandardResistor;
            ptResistance[i] = upt[i] / current[i];
            deltaT[i] = (ptResistance[i] - initialResistance) / (AlphaPt * initialResistance);
        }

        // 2. ========== 加热段拟合 → 热导率 λ ==========
        double tStart = 0.1;
        double tEndHeating = 0.8;
        int startIdx = FindIndex(time, tStart);
        int endIdxHeating = FindIndex(time, tEndHeating);
        if (startIdx < 0) startIdx = 0;
        if (endIdxHeating >= n) endIdxHeating = n - 1;

        var heatingPoints = new List<DataPoint>();
        for (int i = startIdx; i <= endIdxHeating; i++)
        {
            heatingPoints.Add(new DataPoint(Math.Log(time[i]), deltaT[i]));
        }

        double slope = LeastSquaresSlope(heatingPoints);
        if (slope <= 0) slope = 0.0001;

        double avgCurrentSq = current.Average(c => c * c);
        double avgResistance = ptResistance.Average();
        double powerPerLength = (avgCurrentSq * avgResistance) / _config.TestParameters.PlatinumWireLength;
        double lambda = powerPerLength / (4 * Math.PI * slope);

        // 3. ========== 冷却段拟合 → 热扩散率 α ==========
        double coolingStart = 1.0;
        double coolingEnd = 2.0;
        int coolingStartIdx = FindIndex(time, coolingStart);
        int coolingEndIdx = FindIndex(time, coolingEnd);
        if (coolingStartIdx < 0) coolingStartIdx = n / 2;
        if (coolingEndIdx >= n) coolingEndIdx = n - 1;

        var coolingPointsForFit = new List<DataPoint>();
        for (int i = coolingStartIdx; i <= coolingEndIdx; i++)
        {
            if (deltaT[i] > 0.001)
                coolingPointsForFit.Add(new DataPoint(time[i], Math.Log(deltaT[i])));
        }

        double coolingSlope = LeastSquaresSlopeOnTime(coolingPointsForFit);
        double tau = -1.0 / coolingSlope;
        double wireRadius = 0.00003; // 半径 = 直径0.06mm /2
        double alpha = (wireRadius * wireRadius) / (4.0 * tau);
        if (alpha <= 0 || double.IsNaN(alpha) || double.IsInfinity(alpha))
            alpha = 0.12e-6; // 默认值

        // 准备冷却曲线数据点（用于绘图）
        var coolingPoints = new List<DataPoint>();
        for (int i = coolingStartIdx; i <= coolingEndIdx; i++)
        {
            if (deltaT[i] > 0.001)
                coolingPoints.Add(new DataPoint(time[i], deltaT[i]));
        }

        return (lambda, alpha, deltaT, coolingPoints);
    }

    /// <summary>
    /// 查找时间数组中与目标时间最接近的索引
    /// </summary>
    private int FindIndex(double[] timeArray, double targetTime)
    {
        for (int i = 0; i < timeArray.Length; i++)
        {
            if (timeArray[i] >= targetTime)
                return i;
        }
        return timeArray.Length - 1;
    }

    /// <summary>
    /// 最小二乘法拟合斜率 (X轴为横坐标，Y轴为纵坐标) — 用于加热段 ln(t) vs ΔT
    /// </summary>
    private double LeastSquaresSlope(List<DataPoint> points)
    {
        if (points.Count < 2) return 0.001;
        double sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
        foreach (var p in points)
        {
            sumX += p.X;
            sumY += p.Y;
            sumXY += p.X * p.Y;
            sumX2 += p.X * p.X;
        }
        double n = points.Count;
        double denominator = n * sumX2 - sumX * sumX;
        if (Math.Abs(denominator) < 1e-10) return 0.001;
        double slope = (n * sumXY - sumX * sumY) / denominator;
        return slope;
    }

    /// <summary>
    /// 最小二乘法拟合斜率 (X轴为时间t，Y轴为 ln(ΔT)) — 用于冷却段
    /// </summary>
    private double LeastSquaresSlopeOnTime(List<DataPoint> points)
    {
        if (points.Count < 2) return -1.0;
        double sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
        foreach (var p in points)
        {
            sumX += p.X;
            sumY += p.Y;
            sumXY += p.X * p.Y;
            sumX2 += p.X * p.X;
        }
        double n = points.Count;
        double denominator = n * sumX2 - sumX * sumX;
        if (Math.Abs(denominator) < 1e-10) return -1.0;
        double slope = (n * sumXY - sumX * sumY) / denominator;
        return slope;
    }

    private void GenerateTemperatureCurveFromData(double[] time, double[] deltaT, List<DataPoint> coolingPoints)
    {
        if (TemperatureCurveModel == null)
        {
            TemperatureCurveModel = new PlotModel { Title = "温升与冷却曲线", Background = OxyColors.White };
            TemperatureCurveModel.Axes.Add(new LinearAxis { Position = AxisPosition.Bottom, Title = "时间 (s)" });
            TemperatureCurveModel.Axes.Add(new LinearAxis { Position = AxisPosition.Left, Title = "温升 (℃)" });
        }

        // 加热段曲线（红色）
        var heatingSeries = new LineSeries
        {
            Title = $"第{CurrentMeasurementIndex}次测量 - 加热段",
            Color = OxyColors.Red,
            StrokeThickness = 1.5
        };
        for (int i = 0; i < time.Length && time[i] <= 1.0; i++)
        {
            heatingSeries.Points.Add(new DataPoint(time[i], deltaT[i]));
        }
        TemperatureCurveModel.Series.Add(heatingSeries);

        // 冷却曲线（蓝色虚线）
        if (coolingPoints != null && coolingPoints.Count > 0)
        {
            var coolingSeries = new LineSeries
            {
                Title = $"第{CurrentMeasurementIndex}次测量 - 冷却段",
                Color = OxyColors.Blue,
                StrokeThickness = 1.5,
                LineStyle = LineStyle.Dash
            };
            foreach (var p in coolingPoints)
            {
                coolingSeries.Points.Add(p);
            }
            TemperatureCurveModel.Series.Add(coolingSeries);
        }

        TemperatureCurveModel.InvalidatePlot(true);
        CurveTitle = $"已完成 {CurrentMeasurementIndex} 次测量";
    }

    private void GenerateTemperatureCurve(float lambda, float alpha) { /* 旧方法，不再使用 */ }

    private OxyColor GetColorForIndex(int index)
    {
        var colors = new[] { OxyColors.Red, OxyColors.Blue, OxyColors.Green, OxyColors.Orange,
            OxyColors.Purple, OxyColors.Brown, OxyColors.Pink, OxyColors.Cyan, OxyColors.Magenta, OxyColors.Olive };
        return colors[(index - 1) % colors.Length];
    }

    private void CalculateAverages()
    {
        if (Measurements.Count == 0) return;
        AverageThermalConductivity = Measurements.Average(m => m.ThermalConductivity);
        AverageThermalDiffusivity = Measurements.Average(m => m.ThermalDiffusivity);
        AverageVolumetricHeatCapacity = Measurements.Average(m => m.VolumetricHeatCapacity);
    }

    [RelayCommand]
    private void Reset()
    {
        Measurements.Clear();
        AverageThermalConductivity = AverageThermalDiffusivity = AverageVolumetricHeatCapacity = 0;
        CurrentMeasurementIndex = 0;
        StatusMessage = "已重置";
        TestDateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
        TemperatureCurveModel = null;
    }

    [RelayCommand]
    private async Task GenerateReportAsync()
    {
        if (Measurements.Count == 0)
        {
            MessageBox.Show("没有测试数据", "提示");
            return;
        }
        try
        {
            var extraParams = new Dictionary<string, object>
            {
                ["SampleVolume"] = SampleVolume,
                ["BubbleRemoved"] = BubbleRemoved,
                ["UsePressure"] = UsePressure,
                ["PressureValue"] = PressureValue,
                ["IsCleanConfirmed"] = IsCleanConfirmed,
                ["CleanerName"] = CleanerName,
                ["AmbientTemperature"] = AmbientTemperature,
                ["AmbientCalibrated"] = AmbientCalibrated,
                ["PlatinumCompatible"] = PlatinumCompatible,
                ["LiquidReactivityNote"] = LiquidReactivityNote,
                ["InitialResistance"] = PlatinumResistance
            };
            string reportPath = await _reportService.GenerateReportAsync(SampleId, TestTemperature, Measurements.ToList(),
                AverageThermalConductivity, AverageThermalDiffusivity, AverageVolumetricHeatCapacity,
                _config.TestParameters, extraParams);
            MessageBox.Show($"报告已生成: {reportPath}", "成功");
        }
        catch (Exception ex)
        {
            MessageBox.Show($"生成报告失败: {ex.Message}", "错误");
        }
    }

    [RelayCommand]
    private async Task StopTestCommandAsync()
    {
        if (!IsTesting)
        {
            MessageBox.Show("没有正在进行的测试", "提示");
            return;
        }
        _stopRequested = true;
        _testCts?.Cancel();
        StatusMessage = "正在停止测试...";
        await _plcService.WriteCoilAsync(_config.PlcRegisterAddresses.StartCommand, false);
        if (UsePressure)
        {
            await _plcService.WriteCoilAsync(_config.PlcRegisterAddresses.InletValveCoil, false);
            await _plcService.WriteCoilAsync(_config.PlcRegisterAddresses.OutletValveCoil, true);
            await Task.Delay(1000);
            await _plcService.WriteCoilAsync(_config.PlcRegisterAddresses.OutletValveCoil, false);
        }
        IsTesting = false;
        StatusMessage = "测试已停止。";
    }

    [RelayCommand] private async Task PressureCalibrationAsync() => await _plcService.WriteCoilAsync(_config.PlcRegisterAddresses.PressureCalibrationCoil, true);
    [RelayCommand] private async Task ResistanceZeroAsync() => await _plcService.WriteCoilAsync(_config.PlcRegisterAddresses.ResistanceZeroCoil, true);
    [RelayCommand]
    private async Task InletValveControlAsync()
    {
        bool current = await _plcService.ReadCoilAsync(_config.PlcRegisterAddresses.InletValveCoil);
        await _plcService.WriteCoilAsync(_config.PlcRegisterAddresses.InletValveCoil, !current);
        StatusMessage = $"进气阀已{(current ? "关闭" : "开启")}";
    }
    [RelayCommand]
    private async Task OutletValveControlAsync()
    {
        bool current = await _plcService.ReadCoilAsync(_config.PlcRegisterAddresses.OutletValveCoil);
        await _plcService.WriteCoilAsync(_config.PlcRegisterAddresses.OutletValveCoil, !current);
        StatusMessage = $"排气阀已{(current ? "关闭" : "开启")}";
    }
    [RelayCommand] private void ConfirmBubbleRemoved() => BubbleRemoved = true;
    [RelayCommand]
    private void ConfirmClean()
    {
        if (string.IsNullOrWhiteSpace(CleanerName))
        {
            MessageBox.Show("请输入清洁人员姓名", "提示");
            return;
        }
        IsCleanConfirmed = true;
    }
    [RelayCommand] private void ConfirmPlatinumCompatible() => PlatinumCompatible = true;
    [RelayCommand]
    private async Task CalibrateAmbientAsync()
    {
        await EnsureConnected();
        float temp = await _plcService.ReadFloatAsync(_config.PlcRegisterAddresses.Temperature);
        AmbientTemperature = temp;
        AmbientCalibrated = true;
        StatusMessage = $"环境温度校准完成：{AmbientTemperature:F1} °C";
    }
    [RelayCommand] private async Task PerformSystemCalibrationAsync() { /* 系统校准逻辑待实现 */ }
    private async Task EnsureConnected()
    {
        if (!await _plcService.IsConnectedAsync())
            await _plcService.ConnectAsync();
    }
    private async Task UpdateRealTimeParametersAsync()
    {
        if (!await _plcService.IsConnectedAsync()) return;
        try
        {
            float rawPressure = await _plcService.ReadFloatAsync(_config.PlcRegisterAddresses.Pressure);
            ChamberPressure = rawPressure / 10.0;
        }
        catch { }
    }
}