1762 lines
72 KiB
C#
1762 lines
72 KiB
C#
using Avalonia;
|
||
using Avalonia.Controls.ApplicationLifetimes;
|
||
using Avalonia.Platform.Storage;
|
||
using Avalonia.Threading;
|
||
using CommunityToolkit.Mvvm.ComponentModel;
|
||
using CommunityToolkit.Mvvm.Input;
|
||
using Footwear_Test_methodsfor_wholeshoe_Slipresistanceperformance.Models;
|
||
using Footwear_Test_methodsfor_wholeshoe_Slipresistanceperformance.Services;
|
||
using LiveChartsCore;
|
||
using LiveChartsCore.Defaults;
|
||
using LiveChartsCore.SkiaSharpView;
|
||
using LiveChartsCore.SkiaSharpView.Painting;
|
||
using Serilog;
|
||
using SkiaSharp;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Collections.ObjectModel;
|
||
using System.Diagnostics;
|
||
using System.Globalization;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Text.Json;
|
||
using System.Threading.Tasks;
|
||
|
||
namespace Footwear_Test_methodsfor_wholeshoe_Slipresistanceperformance.ViewModels
|
||
{
|
||
public partial class MainWindowViewModel : ViewModelBase, IDisposable
|
||
{
|
||
private const double SampleIntervalSeconds = 1.0 / 50.0;
|
||
private const double DynamicWindowStartSeconds = 0.3;
|
||
private const double DynamicWindowEndSeconds = 0.6;
|
||
private const double StaticPeakSearchEndSeconds = DynamicWindowEndSeconds;
|
||
private const double StaticPeakMinimumRiseN = 1.0;
|
||
private const double StaticPeakDropToleranceN = 0.5;
|
||
private const double SlidingStartDisplacementThresholdMm = 0.05;
|
||
private const double MinimumAnalysisLoadRatio = 0.8;
|
||
// 预触发缓冲：滑动检测前持续缓存的力/位移历史长度，用于回溯真实滑动起点（保证第一个摩擦力峰值被采到）。
|
||
private const double PreTriggerWindowSeconds = 0.5;
|
||
// 滑动检测：载荷达标后只接受明显陡升，避免低幅慢漂移提前把曲线 0 点定错。
|
||
private const double SlidingFrictionTriggerRiseN = 35.0;
|
||
private const double SlidingFrictionTriggerLookbackSeconds = 0.12;
|
||
private const double SlidingFrictionTriggerSlopeN = 25.0;
|
||
private const double SlidingDisplacementFrictionRiseN = 20.0;
|
||
// 回溯滑动起点：在触发前短窗口内找摩擦最低点，贴近标准曲线中首峰前的真实滑动起点。
|
||
private const double SlidingOnsetSearchBackSeconds = 0.12;
|
||
// 曲线/分析窗口：滑动开始后只保留该时长，剔除加载段与滑动后回程，对应标准曲线图的有效区间。
|
||
private const double CurveEndSeconds = 1.0;
|
||
private const int StaticPeakDropConfirmationPointCount = 3;
|
||
private const int MinimumDynamicWindowPointCount = 10;
|
||
private const int StandardTrialCount = 3;
|
||
private const string DefaultPlcPortName = "COM3";
|
||
private const string DefaultAdcPortName = "COM4";
|
||
private const string LegacyPlcPortName = "COM7";
|
||
private const string LegacyAdcPortName = "COM8";
|
||
private static readonly TimeSpan ResetButtonPendingTimeout = TimeSpan.FromMilliseconds(800);
|
||
private static readonly TimeSpan TestButtonPendingTimeout = TimeSpan.FromSeconds(5);
|
||
private static readonly TimeSpan RealtimeCurveTraceInterval = TimeSpan.FromSeconds(1);
|
||
private static readonly TimeSpan LicenseCheckInterval = TimeSpan.FromMinutes(1);
|
||
|
||
private readonly SlipResistanceDeviceService deviceService = new();
|
||
private readonly SlipExcelExportService excelExportService = new();
|
||
private readonly MachineLicenseService licenseService;
|
||
private readonly DispatcherTimer refreshTimer;
|
||
private readonly Stopwatch runStopwatch = new();
|
||
private readonly List<SlipDataPoint> currentRun = [];
|
||
private readonly List<SlipDataPoint> preTriggerBuffer = [];
|
||
private readonly ObservableCollection<ObservablePoint> verticalLoadPoints = [];
|
||
private readonly ObservableCollection<ObservablePoint> horizontalFrictionPoints = [];
|
||
private readonly ObservableCollection<ObservablePoint> frictionCoefficientPoints = [];
|
||
private readonly ObservableCollection<ObservablePoint> displacementPoints = [];
|
||
|
||
private bool isLoadingDeviceSettings;
|
||
private bool wasRunning;
|
||
private bool isTestStartPending;
|
||
private DateTime testStartPendingStartedAt = DateTime.MinValue;
|
||
private bool isResetButtonPending;
|
||
private bool hasObservedResetDeviceBusy;
|
||
private DateTime resetButtonPendingStartedAt = DateTime.MinValue;
|
||
private string activePlcPortName = string.Empty;
|
||
private string activeAdcPortName = string.Empty;
|
||
private int activeBaudRate;
|
||
private List<SlipDataPoint> lastCompletedRun = [];
|
||
private DateTime lastRealtimeCurveTraceLoggedAt = DateTime.MinValue;
|
||
private double runStartDisplacementMm;
|
||
private double slidingStartDisplacementMm;
|
||
private double? slidingStartTimeSeconds;
|
||
private double slidingBaselineFrictionN;
|
||
private bool hasSlidingBaseline;
|
||
private int activeRunLubricantIndex;
|
||
private DateTime lastLicenseCheckAt = DateTime.MinValue;
|
||
private bool isLicenseLockPending;
|
||
private bool licenseLockRequestedRaised;
|
||
private string licenseLockMessage = string.Empty;
|
||
|
||
public event Action<string>? LicenseLockRequested;
|
||
|
||
[ObservableProperty]
|
||
private string testNumber = $"SLIP-{DateTime.Now:yyyyMMdd-HHmm}";
|
||
|
||
[ObservableProperty]
|
||
private string operatorName = string.Empty;
|
||
|
||
[ObservableProperty]
|
||
private string methodName = "GB/T 3903.6-2024";
|
||
|
||
[ObservableProperty]
|
||
private string reportName = string.Empty;
|
||
|
||
[ObservableProperty]
|
||
private string sampleFeature = "整鞋样品 / 瓷砖接触面 / 水平测试";
|
||
|
||
[ObservableProperty]
|
||
private string currentStatus = "设备连接中，等待 PLC 与 ADC 实时数据";
|
||
|
||
[ObservableProperty]
|
||
private int uploadProgress;
|
||
|
||
[ObservableProperty]
|
||
private string manualDistance = "0";
|
||
|
||
[ObservableProperty]
|
||
private int selectedSampleIndex;
|
||
|
||
[ObservableProperty]
|
||
private bool isSettingsDialogOpen;
|
||
|
||
[ObservableProperty]
|
||
private string manualSpeed = "0.00";
|
||
|
||
[ObservableProperty]
|
||
private string manualDisplacement = "0.00";
|
||
|
||
[ObservableProperty]
|
||
private string testSpeed = "0.30";
|
||
|
||
[ObservableProperty]
|
||
private string normalPressureZero = "0";
|
||
|
||
[ObservableProperty]
|
||
private string normalPressureCoefficient = "0.00";
|
||
|
||
[ObservableProperty]
|
||
private string frictionZero1 = "0";
|
||
|
||
[ObservableProperty]
|
||
private string frictionCoefficient1 = "0.00";
|
||
|
||
[ObservableProperty]
|
||
private string frictionZero2 = "0";
|
||
|
||
[ObservableProperty]
|
||
private string frictionCoefficient2 = "0.00";
|
||
|
||
[ObservableProperty]
|
||
private string plcPortName = DefaultPlcPortName;
|
||
|
||
[ObservableProperty]
|
||
private string adcPortName = DefaultAdcPortName;
|
||
|
||
[ObservableProperty]
|
||
private int baudRate = 115200;
|
||
|
||
[ObservableProperty]
|
||
private int selectedShoeSizeIndex;
|
||
|
||
[ObservableProperty]
|
||
private int selectedLubricantIndex;
|
||
|
||
[ObservableProperty]
|
||
private int selectedModeIndex = 2;
|
||
|
||
[ObservableProperty]
|
||
private int selectedSurfaceIndex;
|
||
|
||
[ObservableProperty]
|
||
private string targetLoadText = "400 N";
|
||
|
||
[ObservableProperty]
|
||
private string actualLoadText = "0.0 N";
|
||
|
||
[ObservableProperty]
|
||
private string deviceStatus = "离线";
|
||
|
||
[ObservableProperty]
|
||
private string activeMode = "水平测试模式";
|
||
|
||
[ObservableProperty]
|
||
private string resultSummary = "等待 3 次有效试验";
|
||
|
||
[ObservableProperty]
|
||
private string testButtonText = "测试";
|
||
|
||
[ObservableProperty]
|
||
private bool isTestButtonEnabled = true;
|
||
|
||
[ObservableProperty]
|
||
private string resetButtonText = "复位";
|
||
|
||
[ObservableProperty]
|
||
private int completedTestCount;
|
||
|
||
[ObservableProperty]
|
||
private int dryTestCount;
|
||
|
||
[ObservableProperty]
|
||
private int wetTestCount;
|
||
|
||
[ObservableProperty]
|
||
private int frostTestCount;
|
||
|
||
[ObservableProperty]
|
||
private string staticCoefficient = "0.00";
|
||
|
||
[ObservableProperty]
|
||
private string dynamicCoefficient = "0.00";
|
||
|
||
[ObservableProperty]
|
||
private string verticalPressure = "0.0";
|
||
|
||
[ObservableProperty]
|
||
private string horizontalForce = "0.0";
|
||
|
||
[ObservableProperty]
|
||
private string frictionCoefficient = "0.000";
|
||
|
||
[ObservableProperty]
|
||
private string distance = "0.0";
|
||
|
||
public string TestSpeedText => $"{TestSpeed} m/s";
|
||
public string SampleRateText { get; } = "50 Hz";
|
||
public string BatchNumber { get; } = DateTime.Now.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
|
||
public string UploadProgressText => $"{UploadProgress}%";
|
||
public string StandardReference { get; } = "GB/T 3903.6-2024：实时采集、静/动摩擦系数、三次平均与重测判定";
|
||
|
||
public ObservableCollection<TestSample> Samples { get; } = [];
|
||
|
||
public DrawMarginFrame ChartFrame { get; } = new()
|
||
{
|
||
Fill = new SolidColorPaint(SKColor.Parse("#FFFFFF")),
|
||
Stroke = new SolidColorPaint(SKColor.Parse("#CBD5E1")) { StrokeThickness = 1.4f }
|
||
};
|
||
|
||
public SolidColorPaint LegendTextPaint { get; } = new(SKColor.Parse("#334155"));
|
||
|
||
public ISeries[] Series { get; }
|
||
|
||
public Axis[] XAxes { get; } =
|
||
[
|
||
new Axis
|
||
{
|
||
Name = "时间(s)",
|
||
MinLimit = 0,
|
||
MinStep = 0.05,
|
||
SeparatorsPaint = new SolidColorPaint(SKColor.Parse("#D7E0EA")) { StrokeThickness = 1 },
|
||
SubseparatorsPaint = new SolidColorPaint(SKColor.Parse("#EEF3F8")) { StrokeThickness = 1 },
|
||
SubseparatorsCount = 4,
|
||
LabelsPaint = new SolidColorPaint(SKColor.Parse("#475569")),
|
||
NamePaint = new SolidColorPaint(SKColor.Parse("#334155")),
|
||
TextSize = 12,
|
||
NameTextSize = 13,
|
||
Padding = new LiveChartsCore.Drawing.Padding(4, 3, 4, 3)
|
||
}
|
||
];
|
||
|
||
public Axis[] YAxes { get; } =
|
||
[
|
||
new Axis
|
||
{
|
||
Name = "压力(N)/距离(mm)",
|
||
MinLimit = 0,
|
||
MaxLimit = 800,
|
||
MinStep = 50,
|
||
ForceStepToMin = true,
|
||
SeparatorsPaint = new SolidColorPaint(SKColor.Parse("#D7E0EA")) { StrokeThickness = 1 },
|
||
SubseparatorsPaint = new SolidColorPaint(SKColor.Parse("#EEF3F8")) { StrokeThickness = 1 },
|
||
SubseparatorsCount = 4,
|
||
LabelsPaint = new SolidColorPaint(SKColor.Parse("#475569")),
|
||
NamePaint = new SolidColorPaint(SKColor.Parse("#334155")),
|
||
TextSize = 11,
|
||
NameTextSize = 12,
|
||
Padding = new LiveChartsCore.Drawing.Padding(2, 2, 3, 2)
|
||
},
|
||
new Axis
|
||
{
|
||
Name = "摩擦系数",
|
||
Position = LiveChartsCore.Measure.AxisPosition.End,
|
||
MinLimit = 0,
|
||
MaxLimit = 1.5,
|
||
MinStep = 0.1,
|
||
ForceStepToMin = true,
|
||
LabelsPaint = new SolidColorPaint(SKColor.Parse("#7E22CE")),
|
||
NamePaint = new SolidColorPaint(SKColor.Parse("#7E22CE")),
|
||
SeparatorsPaint = null,
|
||
TextSize = 11,
|
||
NameTextSize = 12,
|
||
Padding = new LiveChartsCore.Drawing.Padding(3, 2, 2, 2)
|
||
}
|
||
];
|
||
|
||
public MainWindowViewModel() : this(new MachineLicenseService())
|
||
{
|
||
}
|
||
|
||
public MainWindowViewModel(MachineLicenseService licenseService)
|
||
{
|
||
this.licenseService = licenseService;
|
||
Log.Information("初始化主页面 ViewModel");
|
||
Series =
|
||
[
|
||
CreateLineSeries("垂直压力(N)", verticalLoadPoints, "#DC2626", 0),
|
||
CreateLineSeries("水平拉力(N)", horizontalFrictionPoints, "#16A34A", 0),
|
||
CreateLineSeries("摩擦系数", frictionCoefficientPoints, "#C026D3", 1),
|
||
CreateLineSeries("距离(mm)", displacementPoints, "#2563EB", 0)
|
||
];
|
||
|
||
LoadDeviceSettings();
|
||
UpdateTargetLoad();
|
||
RestartDeviceConnection();
|
||
_ = LoadPlcParametersAsync();
|
||
|
||
refreshTimer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(20) };
|
||
refreshTimer.Tick += (_, _) => RefreshFromDevice();
|
||
refreshTimer.Start();
|
||
RefreshLicenseState();
|
||
}
|
||
|
||
[RelayCommand]
|
||
private async Task Clear()
|
||
{
|
||
ApplyConnectionSettings();
|
||
BeginResetButtonFeedback();
|
||
|
||
try
|
||
{
|
||
await deviceService.PulseResetAsync();
|
||
CurrentStatus = "已按老代码逻辑发送复位指令 M90";
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Log.Error(ex, "设备指令失败：已按老代码逻辑发送复位指令 M90");
|
||
CurrentStatus = $"设备指令失败：{ex.Message}";
|
||
ClearResetButtonFeedback();
|
||
UpdateResetButtonText(deviceService.CurrentSnapshot);
|
||
}
|
||
}
|
||
|
||
[RelayCommand]
|
||
private void Preload()
|
||
{
|
||
CurrentStatus = "请在 0.2 s 内施加目标垂直载荷，载荷达到后启动滑动测试";
|
||
}
|
||
|
||
[RelayCommand]
|
||
private async Task StartTest()
|
||
{
|
||
if (!IsTestButtonEnabled || isLicenseLockPending)
|
||
{
|
||
return;
|
||
}
|
||
|
||
ApplyConnectionSettings();
|
||
var device = deviceService.CurrentSnapshot;
|
||
if (device.IsTestRunning)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (!ValidateAdcCoefficientsBeforeTest())
|
||
{
|
||
return;
|
||
}
|
||
|
||
BeginTestButtonFeedback();
|
||
try
|
||
{
|
||
await deviceService.PulseStartTestAsync();
|
||
CurrentStatus = "已按老代码逻辑发送测试启动指令 M80，等待 M81 运行状态";
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Log.Error(ex, "设备指令失败：已按老代码逻辑发送测试启动指令 M80");
|
||
CurrentStatus = $"设备指令失败：{ex.Message}";
|
||
ClearTestButtonFeedback();
|
||
UpdateTestButtonState(deviceService.CurrentSnapshot);
|
||
}
|
||
}
|
||
|
||
[RelayCommand]
|
||
private async Task StopTest()
|
||
{
|
||
await RunDeviceCommand(deviceService.PulseStopTestAsync(), "已发送测试停止指令 M83");
|
||
}
|
||
|
||
[RelayCommand]
|
||
private async Task ExportReport()
|
||
{
|
||
var points = currentRun.Count > 0 ? currentRun.ToList() : lastCompletedRun;
|
||
if (points.Count == 0)
|
||
{
|
||
Log.Warning("请求导出 Excel 时没有可导出的实时采样数据：TestNumber={TestNumber}", TestNumber);
|
||
CurrentStatus = "没有可导出的实时采样数据，请先完成一次测试";
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
CurrentStatus = "请选择 Excel 报告保存目录";
|
||
var exportDirectory = await SelectExportDirectoryAsync();
|
||
if (exportDirectory is null)
|
||
{
|
||
Log.Information("用户取消 Excel 导出目录选择：TestNumber={TestNumber}, PointCount={PointCount}", TestNumber, points.Count);
|
||
CurrentStatus = "已取消 Excel 导出";
|
||
return;
|
||
}
|
||
|
||
var actualLoadForReport = FormatActualLoad(points);
|
||
var report = new SlipReportExport(
|
||
TestNumber,
|
||
OperatorName,
|
||
MethodName,
|
||
ReportName,
|
||
SampleFeature,
|
||
CurrentShoeSize(),
|
||
CurrentLubricant(),
|
||
CurrentMode(),
|
||
CurrentSurface(),
|
||
TargetLoadText,
|
||
actualLoadForReport,
|
||
TestSpeedText,
|
||
StandardReference,
|
||
Samples.ToList(),
|
||
points);
|
||
|
||
var path = excelExportService.Export(report, exportDirectory);
|
||
UploadProgress = 100;
|
||
CurrentStatus = $"Excel 已导出：{path}";
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Log.Error(ex, "Excel 导出失败：TestNumber={TestNumber}, PointCount={PointCount}", TestNumber, points.Count);
|
||
CurrentStatus = $"Excel 导出失败：{ex.Message}";
|
||
}
|
||
}
|
||
|
||
private async Task<string?> SelectExportDirectoryAsync()
|
||
{
|
||
var storageProvider = GetStorageProvider();
|
||
if (storageProvider is null || !storageProvider.CanPickFolder)
|
||
{
|
||
var defaultDirectory = SlipExcelExportService.GetDefaultExportDirectory();
|
||
Log.Warning("当前平台无法打开 Excel 导出目录选择器，将使用默认目录：Path={Path}", defaultDirectory);
|
||
return defaultDirectory;
|
||
}
|
||
|
||
var folders = await storageProvider.OpenFolderPickerAsync(new FolderPickerOpenOptions
|
||
{
|
||
Title = "选择报告保存目录",
|
||
AllowMultiple = false,
|
||
SuggestedStartLocation = await TryGetSuggestedExportFolderAsync(storageProvider)
|
||
});
|
||
|
||
var selectedFolder = folders.FirstOrDefault();
|
||
if (selectedFolder is null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var localPath = selectedFolder.TryGetLocalPath();
|
||
if (string.IsNullOrWhiteSpace(localPath) && selectedFolder.Path.IsFile)
|
||
{
|
||
localPath = selectedFolder.Path.LocalPath;
|
||
}
|
||
|
||
if (string.IsNullOrWhiteSpace(localPath))
|
||
{
|
||
throw new InvalidOperationException("选择的目录不是本地文件夹，无法保存 Excel");
|
||
}
|
||
|
||
return localPath;
|
||
}
|
||
|
||
private static async Task<IStorageFolder?> TryGetSuggestedExportFolderAsync(IStorageProvider storageProvider)
|
||
{
|
||
try
|
||
{
|
||
var defaultDirectory = SlipExcelExportService.GetDefaultExportDirectory();
|
||
if (Directory.Exists(defaultDirectory))
|
||
{
|
||
return await storageProvider.TryGetFolderFromPathAsync(defaultDirectory);
|
||
}
|
||
|
||
var parentDirectory = Path.GetDirectoryName(defaultDirectory);
|
||
if (!string.IsNullOrWhiteSpace(parentDirectory) && Directory.Exists(parentDirectory))
|
||
{
|
||
return await storageProvider.TryGetFolderFromPathAsync(parentDirectory);
|
||
}
|
||
|
||
return null;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Log.Warning(ex, "准备 Excel 默认导出目录失败，将不设置目录选择初始位置");
|
||
return null;
|
||
}
|
||
}
|
||
|
||
private static IStorageProvider? GetStorageProvider()
|
||
{
|
||
if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop
|
||
&& desktop.MainWindow is not null)
|
||
{
|
||
return desktop.MainWindow.StorageProvider;
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
[RelayCommand]
|
||
private Task LiftMotion() => RunLicensedDeviceCommand(deviceService.ApplyOldLiftAsync, "提升按老代码逻辑执行：M4=0, M5=1");
|
||
|
||
[RelayCommand]
|
||
private Task LowerMotion() => RunLicensedDeviceCommand(deviceService.ApplyOldLowerAsync, "下降按老代码逻辑执行：M5=0, M4=1");
|
||
|
||
[RelayCommand]
|
||
private Task MoveLeftMotion() => RunLicensedDeviceCommand(deviceService.ToggleOldMoveLeftAsync, "左移按老代码逻辑切换 M1");
|
||
|
||
[RelayCommand]
|
||
private Task MoveRightMotion() => RunLicensedDeviceCommand(deviceService.ToggleOldMoveRightAsync, "右移按老代码逻辑切换 M2");
|
||
|
||
public Task StopAllMotionAsync() => RunDeviceCommand(deviceService.StopAllMotionAsync(), "全部运动已停止");
|
||
|
||
[RelayCommand]
|
||
private void DeleteSelectedSample()
|
||
{
|
||
var sample = Samples.FirstOrDefault(x => x.Index == SelectedSampleIndex);
|
||
if (sample is null)
|
||
{
|
||
CurrentStatus = $"未找到序号 {SelectedSampleIndex} 的实验数据";
|
||
return;
|
||
}
|
||
|
||
Samples.Remove(sample);
|
||
UpdateResultSummary();
|
||
CurrentStatus = $"已删除序号 {SelectedSampleIndex} 的实验数据";
|
||
}
|
||
|
||
[RelayCommand]
|
||
private void ShowSettingsDialog()
|
||
{
|
||
IsSettingsDialogOpen = true;
|
||
}
|
||
|
||
[RelayCommand]
|
||
private void CloseSettingsDialog()
|
||
{
|
||
IsSettingsDialogOpen = false;
|
||
ApplyConnectionSettings();
|
||
}
|
||
|
||
[RelayCommand]
|
||
private void CalibrateNormalPressureZero()
|
||
{
|
||
try
|
||
{
|
||
var zero = deviceService.CaptureCurrentAdcZero();
|
||
NormalPressureZero = zero.NormalPressureZero.ToString(CultureInfo.InvariantCulture);
|
||
SaveAndApplySettings();
|
||
CurrentStatus = "正压力零点已按当前 ADC 原始值采集";
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Log.Error(ex, "正压力零点采集失败");
|
||
CurrentStatus = $"正压力零点采集失败：{ex.Message}";
|
||
}
|
||
}
|
||
|
||
[RelayCommand]
|
||
private void CalibrateFrictionZero()
|
||
{
|
||
try
|
||
{
|
||
var zero = deviceService.CaptureCurrentAdcZero();
|
||
FrictionZero1 = zero.FrictionZero1.ToString(CultureInfo.InvariantCulture);
|
||
FrictionZero2 = zero.FrictionZero2.ToString(CultureInfo.InvariantCulture);
|
||
SaveAndApplySettings();
|
||
CurrentStatus = "摩擦零点已按当前 ADC 原始值采集";
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Log.Error(ex, "摩擦零点采集失败");
|
||
CurrentStatus = $"摩擦零点采集失败：{ex.Message}";
|
||
}
|
||
}
|
||
|
||
partial void OnUploadProgressChanged(int value) => OnPropertyChanged(nameof(UploadProgressText));
|
||
|
||
partial void OnManualSpeedChanged(string value)
|
||
{
|
||
SaveAndApplySettings();
|
||
WriteNumericSetting(value, deviceService.WriteManualSpeedAsync, "手动速度");
|
||
}
|
||
|
||
partial void OnManualDisplacementChanged(string value)
|
||
{
|
||
SaveAndApplySettings();
|
||
WriteNumericSetting(value, deviceService.WriteManualDisplacementAsync, "手动位移");
|
||
}
|
||
|
||
partial void OnTestSpeedChanged(string value)
|
||
{
|
||
OnPropertyChanged(nameof(TestSpeedText));
|
||
SaveAndApplySettings();
|
||
WriteNumericSetting(value, deviceService.WriteTestSpeedAsync, "测试速度");
|
||
}
|
||
|
||
partial void OnNormalPressureZeroChanged(string value) => SaveAndApplySettings();
|
||
|
||
partial void OnNormalPressureCoefficientChanged(string value) => SaveAndApplySettings();
|
||
|
||
partial void OnFrictionZero1Changed(string value) => SaveAndApplySettings();
|
||
|
||
partial void OnFrictionCoefficient1Changed(string value) => SaveAndApplySettings();
|
||
|
||
partial void OnFrictionZero2Changed(string value) => SaveAndApplySettings();
|
||
|
||
partial void OnFrictionCoefficient2Changed(string value) => SaveAndApplySettings();
|
||
|
||
partial void OnPlcPortNameChanged(string value) => SaveAndApplySettings();
|
||
|
||
partial void OnAdcPortNameChanged(string value) => SaveAndApplySettings();
|
||
|
||
partial void OnBaudRateChanged(int value) => SaveAndApplySettings();
|
||
|
||
partial void OnSelectedShoeSizeIndexChanged(int value) => UpdateTargetLoad();
|
||
|
||
partial void OnSelectedModeIndexChanged(int value)
|
||
{
|
||
ActiveMode = CurrentMode();
|
||
}
|
||
|
||
public void Dispose()
|
||
{
|
||
refreshTimer.Stop();
|
||
try
|
||
{
|
||
deviceService.StopAllMotionAsync().Wait(500);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Log.Warning(ex, "关闭窗口时停止全部运动失败");
|
||
}
|
||
|
||
deviceService.Dispose();
|
||
}
|
||
|
||
public void RefreshLicenseState()
|
||
{
|
||
var check = licenseService.Check(updateHeartbeat: true);
|
||
lastLicenseCheckAt = DateTime.UtcNow;
|
||
isLicenseLockPending = !check.CanUseSoftware;
|
||
licenseLockMessage = check.Message;
|
||
if (!isLicenseLockPending)
|
||
{
|
||
licenseLockRequestedRaised = false;
|
||
}
|
||
|
||
UpdateTestButtonState(deviceService.CurrentSnapshot);
|
||
}
|
||
|
||
private void RefreshFromDevice()
|
||
{
|
||
var device = deviceService.CurrentSnapshot;
|
||
CheckRuntimeLicense(device);
|
||
if (device.IsConnected)
|
||
{
|
||
DeviceStatus = device.IsTestRunning ? "联机 / 测试中" : device.IsResetting ? "联机 / 复位中" : "联机 / 待机";
|
||
UpdateResetButtonText(device);
|
||
VerticalPressure = device.VerticalLoadN.ToString("F1", CultureInfo.InvariantCulture);
|
||
HorizontalForce = device.HorizontalFrictionN.ToString("F1", CultureInfo.InvariantCulture);
|
||
FrictionCoefficient = device.FrictionCoefficient.ToString("F3", CultureInfo.InvariantCulture);
|
||
Distance = device.DisplacementMm.ToString("F1", CultureInfo.InvariantCulture);
|
||
ActualLoadText = $"{VerticalPressure} N";
|
||
}
|
||
else
|
||
{
|
||
DeviceStatus = IsAdcCalibrationError(device.LastError) ? "数据无效" : "离线";
|
||
UpdateResetButtonText(device);
|
||
VerticalPressure = "--";
|
||
HorizontalForce = "--";
|
||
FrictionCoefficient = "--";
|
||
Distance = "--";
|
||
ActualLoadText = "-- N";
|
||
}
|
||
|
||
UpdateTestButtonState(device);
|
||
|
||
if (!device.IsConnected && !string.IsNullOrWhiteSpace(device.LastError))
|
||
{
|
||
CurrentStatus = IsAdcCalibrationError(device.LastError)
|
||
? $"数据无效：{device.LastError}"
|
||
: $"设备离线：{device.LastError}";
|
||
}
|
||
|
||
var isRecording = device.IsConnected && device.IsTestRunning;
|
||
if (!wasRunning && isRecording)
|
||
{
|
||
BeginRun();
|
||
}
|
||
|
||
if (isRecording)
|
||
{
|
||
RecordPoint(device);
|
||
}
|
||
|
||
if (wasRunning && !isRecording)
|
||
{
|
||
if (device.IsConnected)
|
||
{
|
||
CompleteRun();
|
||
}
|
||
else
|
||
{
|
||
AbortRun("设备离线，本次采集已停止，未生成试验结果");
|
||
}
|
||
}
|
||
|
||
wasRunning = isRecording;
|
||
}
|
||
|
||
private void BeginTestButtonFeedback()
|
||
{
|
||
isTestStartPending = true;
|
||
testStartPendingStartedAt = DateTime.UtcNow;
|
||
TestButtonText = "测试中";
|
||
IsTestButtonEnabled = false;
|
||
}
|
||
|
||
private void ClearTestButtonFeedback()
|
||
{
|
||
isTestStartPending = false;
|
||
testStartPendingStartedAt = DateTime.MinValue;
|
||
}
|
||
|
||
private void UpdateTestButtonState(SlipDeviceSnapshot device)
|
||
{
|
||
if (isLicenseLockPending)
|
||
{
|
||
ClearTestButtonFeedback();
|
||
TestButtonText = "授权到期";
|
||
IsTestButtonEnabled = false;
|
||
return;
|
||
}
|
||
|
||
if (device.IsTestRunning)
|
||
{
|
||
ClearTestButtonFeedback();
|
||
TestButtonText = "测试中";
|
||
IsTestButtonEnabled = false;
|
||
return;
|
||
}
|
||
|
||
if (isTestStartPending
|
||
&& DateTime.UtcNow - testStartPendingStartedAt < TestButtonPendingTimeout)
|
||
{
|
||
TestButtonText = "测试中";
|
||
IsTestButtonEnabled = false;
|
||
return;
|
||
}
|
||
|
||
ClearTestButtonFeedback();
|
||
TestButtonText = "测试";
|
||
IsTestButtonEnabled = true;
|
||
}
|
||
|
||
private void CheckRuntimeLicense(SlipDeviceSnapshot device)
|
||
{
|
||
if (DateTime.UtcNow - lastLicenseCheckAt >= LicenseCheckInterval)
|
||
{
|
||
var check = licenseService.Check(updateHeartbeat: true);
|
||
lastLicenseCheckAt = DateTime.UtcNow;
|
||
isLicenseLockPending = !check.CanUseSoftware;
|
||
licenseLockMessage = check.Message;
|
||
}
|
||
|
||
if (isLicenseLockPending
|
||
&& !device.IsTestRunning
|
||
&& !device.IsResetting
|
||
&& !licenseLockRequestedRaised)
|
||
{
|
||
licenseLockRequestedRaised = true;
|
||
LicenseLockRequested?.Invoke(licenseLockMessage);
|
||
}
|
||
}
|
||
|
||
private void BeginResetButtonFeedback()
|
||
{
|
||
isResetButtonPending = true;
|
||
hasObservedResetDeviceBusy = false;
|
||
resetButtonPendingStartedAt = DateTime.UtcNow;
|
||
ResetButtonText = "复位中";
|
||
}
|
||
|
||
private void ClearResetButtonFeedback()
|
||
{
|
||
isResetButtonPending = false;
|
||
hasObservedResetDeviceBusy = false;
|
||
resetButtonPendingStartedAt = DateTime.MinValue;
|
||
}
|
||
|
||
private void UpdateResetButtonText(SlipDeviceSnapshot device)
|
||
{
|
||
if (device.IsResetting)
|
||
{
|
||
hasObservedResetDeviceBusy = true;
|
||
}
|
||
else if (!device.IsConnected
|
||
|| hasObservedResetDeviceBusy
|
||
|| (isResetButtonPending && DateTime.UtcNow - resetButtonPendingStartedAt >= ResetButtonPendingTimeout))
|
||
{
|
||
ClearResetButtonFeedback();
|
||
}
|
||
|
||
ResetButtonText = device.IsResetting || isResetButtonPending ? "复位中" : "复位";
|
||
}
|
||
|
||
private void BeginRun()
|
||
{
|
||
currentRun.Clear();
|
||
preTriggerBuffer.Clear();
|
||
verticalLoadPoints.Clear();
|
||
horizontalFrictionPoints.Clear();
|
||
frictionCoefficientPoints.Clear();
|
||
displacementPoints.Clear();
|
||
runStartDisplacementMm = deviceService.CurrentSnapshot.DisplacementMm;
|
||
slidingStartDisplacementMm = runStartDisplacementMm;
|
||
slidingStartTimeSeconds = null;
|
||
slidingBaselineFrictionN = 0;
|
||
hasSlidingBaseline = false;
|
||
activeRunLubricantIndex = SelectedLubricantIndex;
|
||
runStopwatch.Restart();
|
||
UploadProgress = 0;
|
||
lastRealtimeCurveTraceLoggedAt = DateTime.MinValue;
|
||
CurrentStatus = "测试运行：等待检测有效滑动开始，曲线尚未记录";
|
||
Log.Information(
|
||
"测试开始：TestNumber={TestNumber}, TargetLoad={TargetLoad}, TestSpeed={TestSpeed}, StartDisplacement={StartDisplacement:F3}mm, CurveRecording=等待有效滑动开始",
|
||
TestNumber,
|
||
TargetLoadText,
|
||
TestSpeedText,
|
||
runStartDisplacementMm);
|
||
}
|
||
|
||
private void RecordPoint(SlipDeviceSnapshot device)
|
||
{
|
||
var elapsedSinceTestStart = runStopwatch.Elapsed.TotalSeconds;
|
||
var samplePoint = new SlipDataPoint(
|
||
device.Timestamp,
|
||
elapsedSinceTestStart,
|
||
device.VerticalLoadN,
|
||
device.HorizontalFrictionN,
|
||
device.DisplacementMm,
|
||
device.FrictionCoefficient);
|
||
|
||
// 滑动起点尚未确定：把样本缓存进滚动预触发缓冲，并尝试检测滑动起点。
|
||
if (!slidingStartTimeSeconds.HasValue)
|
||
{
|
||
UpdatePreTrigger(samplePoint);
|
||
return;
|
||
}
|
||
|
||
var standardTime = elapsedSinceTestStart - slidingStartTimeSeconds.Value;
|
||
// 只保留滑动开始后 CurveEndSeconds 区间，剔除滑动结束后的回程/抬升段。
|
||
if (standardTime > CurveEndSeconds)
|
||
{
|
||
return;
|
||
}
|
||
|
||
AppendCurvePoint(samplePoint, standardTime);
|
||
}
|
||
|
||
// 滑动检测前持续缓存样本，并在载荷达标后用水平摩擦力陡升判定滑动起点。
|
||
private void UpdatePreTrigger(SlipDataPoint samplePoint)
|
||
{
|
||
preTriggerBuffer.Add(samplePoint);
|
||
var oldestAllowed = samplePoint.TimeSeconds - PreTriggerWindowSeconds;
|
||
while (preTriggerBuffer.Count > 0 && preTriggerBuffer[0].TimeSeconds < oldestAllowed)
|
||
{
|
||
preTriggerBuffer.RemoveAt(0);
|
||
}
|
||
|
||
var minimumAnalysisLoad = GetMinimumAnalysisLoad();
|
||
if (samplePoint.VerticalLoadN < minimumAnalysisLoad)
|
||
{
|
||
// 载荷尚未到达规定压力（静置接触前），基线需在载荷达标后重新捕获。
|
||
hasSlidingBaseline = false;
|
||
return;
|
||
}
|
||
|
||
if (!hasSlidingBaseline)
|
||
{
|
||
// 载荷首次达标：以当前（仅法向加载、尚未水平滑动）的摩擦力为静置接触基线。
|
||
slidingBaselineFrictionN = samplePoint.HorizontalFrictionN;
|
||
hasSlidingBaseline = true;
|
||
return;
|
||
}
|
||
|
||
var frictionRiseFromBaseline = samplePoint.HorizontalFrictionN - slidingBaselineFrictionN;
|
||
var lookbackPoint = FindLookbackPoint(samplePoint.TimeSeconds - SlidingFrictionTriggerLookbackSeconds);
|
||
var frictionRiseFromLookback = lookbackPoint is null
|
||
? 0
|
||
: samplePoint.HorizontalFrictionN - lookbackPoint.HorizontalFrictionN;
|
||
var frictionRose = frictionRiseFromBaseline >= SlidingFrictionTriggerRiseN
|
||
&& frictionRiseFromLookback >= SlidingFrictionTriggerSlopeN;
|
||
var displacementMoved = Math.Abs(samplePoint.DisplacementMm - runStartDisplacementMm) >= SlidingStartDisplacementThresholdMm;
|
||
var displacementWithFriction = displacementMoved
|
||
&& frictionRiseFromBaseline >= SlidingDisplacementFrictionRiseN;
|
||
if (frictionRose || displacementWithFriction)
|
||
{
|
||
MarkSlidingStartFromBuffer(frictionRose ? "FrictionSharpRise" : "DisplacementWithFrictionRise");
|
||
return;
|
||
}
|
||
|
||
if (displacementMoved)
|
||
{
|
||
Log.Debug(
|
||
"滑动起点候选未触发：TestNumber={TestNumber}, Reason=DisplacementWithoutFrictionRise, DisplacementDelta={DisplacementDelta:F3}mm, FrictionRiseFromBaseline={FrictionRiseFromBaseline:F3}N, FrictionRiseFromLookback={FrictionRiseFromLookback:F3}N, BaselineFriction={BaselineFriction:F3}N, CurrentFriction={CurrentFriction:F3}N",
|
||
TestNumber,
|
||
Math.Abs(samplePoint.DisplacementMm - runStartDisplacementMm),
|
||
frictionRiseFromBaseline,
|
||
frictionRiseFromLookback,
|
||
slidingBaselineFrictionN,
|
||
samplePoint.HorizontalFrictionN);
|
||
}
|
||
}
|
||
|
||
private SlipDataPoint? FindLookbackPoint(double targetTime)
|
||
{
|
||
for (var index = preTriggerBuffer.Count - 1; index >= 0; index--)
|
||
{
|
||
if (preTriggerBuffer[index].TimeSeconds <= targetTime)
|
||
{
|
||
return preTriggerBuffer[index];
|
||
}
|
||
}
|
||
|
||
return preTriggerBuffer.Count > 0 ? preTriggerBuffer[0] : null;
|
||
}
|
||
|
||
// 回溯预触发缓冲到摩擦力陡升前的低点设为 t=0，并把该时刻起的缓冲点补进曲线，保证第一个峰值被采到。
|
||
private void MarkSlidingStartFromBuffer(string trigger)
|
||
{
|
||
var triggerPoint = preTriggerBuffer[^1];
|
||
var earliestOnsetTime = triggerPoint.TimeSeconds - SlidingOnsetSearchBackSeconds;
|
||
var onsetIndex = preTriggerBuffer.Count - 1;
|
||
for (var index = preTriggerBuffer.Count - 1; index >= 0; index--)
|
||
{
|
||
if (preTriggerBuffer[index].TimeSeconds < earliestOnsetTime)
|
||
{
|
||
break;
|
||
}
|
||
|
||
if (preTriggerBuffer[index].HorizontalFrictionN <= preTriggerBuffer[onsetIndex].HorizontalFrictionN)
|
||
{
|
||
onsetIndex = index;
|
||
}
|
||
}
|
||
|
||
var onset = preTriggerBuffer[onsetIndex];
|
||
slidingStartTimeSeconds = onset.TimeSeconds;
|
||
slidingStartDisplacementMm = onset.DisplacementMm;
|
||
|
||
for (var index = onsetIndex; index < preTriggerBuffer.Count; index++)
|
||
{
|
||
var buffered = preTriggerBuffer[index];
|
||
var standardTime = buffered.TimeSeconds - onset.TimeSeconds;
|
||
if (standardTime > CurveEndSeconds)
|
||
{
|
||
break;
|
||
}
|
||
|
||
AppendCurvePoint(buffered, standardTime);
|
||
}
|
||
|
||
preTriggerBuffer.Clear();
|
||
|
||
CurrentStatus = "已检测到有效滑动开始：曲线从 0.000 s 开始记录";
|
||
Log.Information(
|
||
"检测到有效滑动开始并建立曲线零点：TestNumber={TestNumber}, Trigger={Trigger}, SlidingStartTime={SlidingStartTime:F3}s, TriggerTime={TriggerTime:F3}s, BaselineFriction={BaselineFriction:F3}N, OnsetFriction={OnsetFriction:F3}N, TriggerFriction={TriggerFriction:F3}N, FrictionRise={FrictionRise:F3}N, OnsetDisplacement={OnsetDisplacement:F3}mm, TriggerDisplacement={TriggerDisplacement:F3}mm, FlushedPointCount={FlushedPointCount}",
|
||
TestNumber,
|
||
trigger,
|
||
onset.TimeSeconds,
|
||
triggerPoint.TimeSeconds,
|
||
slidingBaselineFrictionN,
|
||
onset.HorizontalFrictionN,
|
||
triggerPoint.HorizontalFrictionN,
|
||
triggerPoint.HorizontalFrictionN - onset.HorizontalFrictionN,
|
||
slidingStartDisplacementMm,
|
||
triggerPoint.DisplacementMm,
|
||
currentRun.Count);
|
||
}
|
||
|
||
// 把一个样本按标准时间（相对滑动起点）追加到数据与曲线集合，保持各曲线序列同步（节流到 SampleIntervalSeconds）。
|
||
private void AppendCurvePoint(SlipDataPoint source, double standardTime)
|
||
{
|
||
standardTime = Math.Max(0, standardTime);
|
||
if (currentRun.Count > 0 && standardTime - currentRun[^1].TimeSeconds < SampleIntervalSeconds)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var point = new SlipDataPoint(
|
||
source.Timestamp,
|
||
standardTime,
|
||
source.VerticalLoadN,
|
||
source.HorizontalFrictionN,
|
||
Math.Abs(source.DisplacementMm - slidingStartDisplacementMm),
|
||
source.FrictionCoefficient);
|
||
|
||
currentRun.Add(point);
|
||
verticalLoadPoints.Add(new ObservablePoint(standardTime, point.VerticalLoadN));
|
||
horizontalFrictionPoints.Add(new ObservablePoint(standardTime, point.HorizontalFrictionN));
|
||
UpdateLinearDisplacementSeries(point);
|
||
frictionCoefficientPoints.Add(new ObservablePoint(standardTime, point.FrictionCoefficient));
|
||
|
||
UploadProgress = Math.Min(99, currentRun.Count);
|
||
TraceRealtimeCurvePoint(point);
|
||
}
|
||
|
||
private void CompleteRun()
|
||
{
|
||
runStopwatch.Stop();
|
||
LogRealtimeCurveSummary("测试停止");
|
||
RecordCompletedTest();
|
||
if (!slidingStartTimeSeconds.HasValue)
|
||
{
|
||
Log.Warning(
|
||
"测试停止但未检测到有效滑动开始：TestNumber={TestNumber}, StartDisplacement={StartDisplacement:F3}mm, DisplacementThreshold={DisplacementThreshold:F3}mm, MinimumAnalysisLoad={MinimumAnalysisLoad:F3}N, CurvePointCount={CurvePointCount}",
|
||
TestNumber,
|
||
runStartDisplacementMm,
|
||
SlidingStartDisplacementThresholdMm,
|
||
GetMinimumAnalysisLoad(),
|
||
currentRun.Count);
|
||
CurrentStatus = "测试已停止，但未检测到有效滑动开始，曲线未记录且未生成结果";
|
||
return;
|
||
}
|
||
|
||
if (currentRun.Count < 3)
|
||
{
|
||
Log.Warning(
|
||
"测试停止但滑动后采样点不足：TestNumber={TestNumber}, SlidingDetectionDelay={SlidingDetectionDelay:F3}s, PointCount={PointCount}",
|
||
TestNumber,
|
||
slidingStartTimeSeconds.Value,
|
||
currentRun.Count);
|
||
CurrentStatus = "测试已停止，但有效采样点不足，未生成结果";
|
||
return;
|
||
}
|
||
|
||
lastCompletedRun = currentRun.ToList();
|
||
var minimumAnalysisLoad = GetMinimumAnalysisLoad();
|
||
const double slidingStartTime = 0;
|
||
var staticPeak = FindStaticPeak(currentRun);
|
||
var peak = staticPeak.Point;
|
||
var dynamicWindow = currentRun
|
||
.Where(IsInDynamicWindow)
|
||
.ToList();
|
||
if (dynamicWindow.Count < MinimumDynamicWindowPointCount)
|
||
{
|
||
var firstWindowPoint = dynamicWindow.FirstOrDefault();
|
||
var lastWindowPoint = dynamicWindow.LastOrDefault();
|
||
Log.Warning(
|
||
"测试停止但动摩擦窗口采样点不足：TestNumber={TestNumber}, PointCount={PointCount}, SlidingDetectionDelay={SlidingDetectionDelay:F3}s, StandardTimeOrigin={StandardTimeOrigin:F3}s, DynamicWindow=滑动开始后0.300-0.600s, DynamicWindowPointCount={DynamicWindowPointCount}, RequiredPointCount={RequiredPointCount}, ActualWindowStart={ActualWindowStart}, ActualWindowEnd={ActualWindowEnd}, FirstSampleTime={FirstSampleTime:F3}s, LastSampleTime={LastSampleTime:F3}s",
|
||
TestNumber,
|
||
currentRun.Count,
|
||
slidingStartTimeSeconds.Value,
|
||
slidingStartTime,
|
||
dynamicWindow.Count,
|
||
MinimumDynamicWindowPointCount,
|
||
FormatStandardTime(firstWindowPoint),
|
||
FormatStandardTime(lastWindowPoint),
|
||
currentRun[0].TimeSeconds,
|
||
currentRun[^1].TimeSeconds);
|
||
CurrentStatus = "测试已停止，0.3 s~0.6 s 有效采样点不足，未生成结果";
|
||
return;
|
||
}
|
||
|
||
var staticCoefficientValue = CalculateCoefficient(peak.HorizontalFrictionN, peak.VerticalLoadN);
|
||
var dynamicForce = dynamicWindow.Average(point => point.HorizontalFrictionN);
|
||
var dynamicLoad = dynamicWindow.Average(point => point.VerticalLoadN);
|
||
if (peak.VerticalLoadN < minimumAnalysisLoad || dynamicLoad < minimumAnalysisLoad)
|
||
{
|
||
Log.Warning(
|
||
"测试停止但静/动摩擦窗口载荷不足：TestNumber={TestNumber}, SlidingDetectionDelay={SlidingDetectionDelay:F3}s, MinimumAnalysisLoad={MinimumAnalysisLoad:F3}N, StaticLoad={StaticLoad:F3}N, DynamicAvgLoad={DynamicAvgLoad:F3}N, StaticPoint={StaticPoint}, DynamicPointCount={DynamicPointCount}",
|
||
TestNumber,
|
||
slidingStartTimeSeconds.Value,
|
||
minimumAnalysisLoad,
|
||
peak.VerticalLoadN,
|
||
dynamicLoad,
|
||
FormatDataPoint(peak),
|
||
dynamicWindow.Count);
|
||
CurrentStatus = "测试已停止，静/动摩擦窗口载荷不足，未生成结果";
|
||
return;
|
||
}
|
||
|
||
var dynamicCoefficientValue = CalculateCoefficient(dynamicForce, dynamicLoad);
|
||
var verdict = NeedsRetest(staticCoefficientValue, dynamicCoefficientValue) ? "需重测" : "有效";
|
||
var nextIndex = Samples.Count == 0 ? 1 : Samples.Max(sample => sample.Index) + 1;
|
||
var peakIndex = currentRun.IndexOf(peak) + 1;
|
||
var dynamicStart = dynamicWindow[0].TimeSeconds;
|
||
var dynamicEnd = dynamicWindow[^1].TimeSeconds;
|
||
|
||
Log.Information(
|
||
"静/动摩擦计算明细：TestNumber={TestNumber}, PointCount={PointCount}, SlidingDetectionDelay={SlidingDetectionDelay:F3}s, StandardTimeOrigin={StandardTimeOrigin:F3}s, AbsoluteSlidingStartDisplacement={AbsoluteSlidingStartDisplacement:F3}mm, StaticSearchWindow=滑动开始后首个峰值0.000-{StaticSearchEnd:F3}s, StaticPeakMode={StaticPeakMode}, StaticPointIndex={StaticPointIndex}, StaticTime={StaticTime:F3}s, StaticFriction={StaticFriction:F3}N, StaticLoad={StaticLoad:F3}N, StaticCoefficient={StaticCoefficient:F5}, DynamicWindow=滑动开始后{DynamicWindowStart:F3}-{DynamicWindowEnd:F3}s, DynamicActualWindow={DynamicActualStart:F3}-{DynamicActualEnd:F3}s, DynamicPointCount={DynamicPointCount}, DynamicAvgFriction={DynamicAvgFriction:F3}N, DynamicAvgLoad={DynamicAvgLoad:F3}N, DynamicCoefficient={DynamicCoefficient:F5}",
|
||
TestNumber,
|
||
currentRun.Count,
|
||
slidingStartTimeSeconds.Value,
|
||
slidingStartTime,
|
||
slidingStartDisplacementMm,
|
||
StaticPeakSearchEndSeconds,
|
||
staticPeak.Mode,
|
||
peakIndex,
|
||
peak.TimeSeconds,
|
||
peak.HorizontalFrictionN,
|
||
peak.VerticalLoadN,
|
||
staticCoefficientValue,
|
||
DynamicWindowStartSeconds,
|
||
DynamicWindowEndSeconds,
|
||
dynamicStart,
|
||
dynamicEnd,
|
||
dynamicWindow.Count,
|
||
dynamicForce,
|
||
dynamicLoad,
|
||
dynamicCoefficientValue);
|
||
|
||
Samples.Insert(0, new TestSample(
|
||
nextIndex,
|
||
DateTime.Now.ToString("HH:mm:ss", CultureInfo.InvariantCulture),
|
||
staticCoefficientValue.ToString("F2", CultureInfo.InvariantCulture),
|
||
dynamicCoefficientValue.ToString("F2", CultureInfo.InvariantCulture),
|
||
verdict,
|
||
staticCoefficientValue,
|
||
dynamicCoefficientValue));
|
||
|
||
StaticCoefficient = staticCoefficientValue.ToString("F2", CultureInfo.InvariantCulture);
|
||
DynamicCoefficient = dynamicCoefficientValue.ToString("F2", CultureInfo.InvariantCulture);
|
||
UpdateResultSummary();
|
||
UploadProgress = 100;
|
||
CurrentStatus = verdict == "有效"
|
||
? "测试完成：已按标准生成静/动摩擦系数"
|
||
: "测试完成：最近三次结果差异超过 10%，建议重新测试";
|
||
Log.Information(
|
||
"测试完成：TestNumber={TestNumber}, PointCount={PointCount}, StaticCoefficient={StaticCoefficient:F3}, DynamicCoefficient={DynamicCoefficient:F3}, Verdict={Verdict}",
|
||
TestNumber,
|
||
currentRun.Count,
|
||
staticCoefficientValue,
|
||
dynamicCoefficientValue,
|
||
verdict);
|
||
}
|
||
|
||
private void RecordCompletedTest()
|
||
{
|
||
CompletedTestCount++;
|
||
switch (activeRunLubricantIndex)
|
||
{
|
||
case 1:
|
||
case 2:
|
||
WetTestCount++;
|
||
break;
|
||
case 3:
|
||
FrostTestCount++;
|
||
break;
|
||
default:
|
||
DryTestCount++;
|
||
break;
|
||
}
|
||
|
||
Log.Information(
|
||
"完整测试次数已更新：TestNumber={TestNumber}, Lubricant={Lubricant}, CompletedTestCount={CompletedTestCount}, DryTestCount={DryTestCount}, WetTestCount={WetTestCount}, FrostTestCount={FrostTestCount}",
|
||
TestNumber,
|
||
CurrentLubricant(activeRunLubricantIndex),
|
||
CompletedTestCount,
|
||
DryTestCount,
|
||
WetTestCount,
|
||
FrostTestCount);
|
||
}
|
||
|
||
private void AbortRun(string message)
|
||
{
|
||
runStopwatch.Stop();
|
||
Log.Warning(
|
||
"测试采集中止：TestNumber={TestNumber}, PointCount={PointCount}, Message={Message}",
|
||
TestNumber,
|
||
currentRun.Count,
|
||
message);
|
||
CurrentStatus = message;
|
||
}
|
||
|
||
private bool NeedsRetest(double staticCoefficientValue, double dynamicCoefficientValue)
|
||
{
|
||
var previous = Samples.Take(StandardTrialCount - 1).Reverse().ToList();
|
||
if (previous.Count < StandardTrialCount - 1)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
var staticValues = previous.Select(sample => sample.StaticCoefficientValue).Append(staticCoefficientValue).ToArray();
|
||
var dynamicValues = previous.Select(sample => sample.DynamicCoefficientValue).Append(dynamicCoefficientValue).ToArray();
|
||
return HasSystematicTrendExceedingTenPercent(staticValues) || HasSystematicTrendExceedingTenPercent(dynamicValues);
|
||
}
|
||
|
||
private static bool HasSystematicTrendExceedingTenPercent(double[] values)
|
||
{
|
||
var isIncreasing = values.Zip(values.Skip(1), (left, right) => right > left).All(result => result);
|
||
var isDecreasing = values.Zip(values.Skip(1), (left, right) => right < left).All(result => result);
|
||
if (!isIncreasing && !isDecreasing)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
var average = values.Average();
|
||
if (Math.Abs(average) < 0.0001)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
return (values.Max() - values.Min()) / Math.Abs(average) > 0.10;
|
||
}
|
||
|
||
private void UpdateResultSummary()
|
||
{
|
||
var latest = Samples.Take(StandardTrialCount).ToList();
|
||
if (latest.Count == 0)
|
||
{
|
||
ResultSummary = "等待 3 次有效试验";
|
||
return;
|
||
}
|
||
|
||
if (latest.Count < StandardTrialCount)
|
||
{
|
||
ResultSummary = $"已完成 {latest.Count}/3 次有效试验";
|
||
return;
|
||
}
|
||
|
||
var staticAverage = latest.Average(sample => sample.StaticCoefficientValue);
|
||
var dynamicAverage = latest.Average(sample => sample.DynamicCoefficientValue);
|
||
ResultSummary = $"近 3 次平均 静 {staticAverage:F2} / 动 {dynamicAverage:F2}";
|
||
}
|
||
|
||
private double GetMinimumAnalysisLoad() =>
|
||
TryParseLoadValue(TargetLoadText, out var targetLoad)
|
||
? Math.Max(1, targetLoad * MinimumAnalysisLoadRatio)
|
||
: 1;
|
||
|
||
private static string FormatActualLoad(IReadOnlyList<SlipDataPoint> points)
|
||
{
|
||
var actualLoad = points.Average(point => point.VerticalLoadN);
|
||
return $"{actualLoad.ToString("F1", CultureInfo.InvariantCulture)} N";
|
||
}
|
||
|
||
private static bool TryParseLoadValue(string value, out double load)
|
||
{
|
||
var numeric = new string(value
|
||
.Where(character => char.IsDigit(character) || character is '.' or '-' or '+')
|
||
.ToArray());
|
||
return double.TryParse(numeric, NumberStyles.Float, CultureInfo.InvariantCulture, out load);
|
||
}
|
||
|
||
private static StaticPeakSelection FindStaticPeak(IReadOnlyList<SlipDataPoint> points)
|
||
{
|
||
var searchWindow = points
|
||
.Where(point => point.TimeSeconds >= 0
|
||
&& point.TimeSeconds <= StaticPeakSearchEndSeconds)
|
||
.ToList();
|
||
if (searchWindow.Count == 0)
|
||
{
|
||
return new StaticPeakSelection(points[0], "NoStaticWindowFallback");
|
||
}
|
||
|
||
var firstFriction = searchWindow[0].HorizontalFrictionN;
|
||
var peakIndex = 0;
|
||
for (var index = 1; index < searchWindow.Count; index++)
|
||
{
|
||
if (searchWindow[index].HorizontalFrictionN > searchWindow[peakIndex].HorizontalFrictionN)
|
||
{
|
||
peakIndex = index;
|
||
}
|
||
|
||
var peak = searchWindow[peakIndex];
|
||
var hasMeaningfulRise = peak.HorizontalFrictionN - firstFriction >= StaticPeakMinimumRiseN;
|
||
if (!hasMeaningfulRise)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
var confirmationEnd = Math.Min(
|
||
searchWindow.Count - 1,
|
||
index + StaticPeakDropConfirmationPointCount - 1);
|
||
if (confirmationEnd - index + 1 < StaticPeakDropConfirmationPointCount)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
var isConfirmedFalling = true;
|
||
for (var confirmationIndex = index; confirmationIndex <= confirmationEnd; confirmationIndex++)
|
||
{
|
||
if (searchWindow[confirmationIndex].HorizontalFrictionN > peak.HorizontalFrictionN - StaticPeakDropToleranceN)
|
||
{
|
||
isConfirmedFalling = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (isConfirmedFalling)
|
||
{
|
||
return new StaticPeakSelection(peak, "FirstConfirmedPeak");
|
||
}
|
||
}
|
||
|
||
return new StaticPeakSelection(
|
||
searchWindow.MaxBy(point => point.HorizontalFrictionN) ?? searchWindow[0],
|
||
"MaxFallback");
|
||
}
|
||
|
||
private sealed record StaticPeakSelection(SlipDataPoint Point, string Mode);
|
||
|
||
private static double CalculateCoefficient(double frictionForce, double verticalLoad) =>
|
||
Math.Abs(verticalLoad) > 0.0001 ? frictionForce / verticalLoad : 0;
|
||
|
||
private void LogRealtimeCurveSummary(string stage)
|
||
{
|
||
var expectedCount = currentRun.Count;
|
||
var lastPoint = currentRun.Count > 0 ? currentRun[^1] : null;
|
||
var countsMatch =
|
||
verticalLoadPoints.Count == expectedCount
|
||
&& horizontalFrictionPoints.Count == expectedCount
|
||
&& frictionCoefficientPoints.Count == expectedCount
|
||
&& IsLinearDisplacementSeriesSynchronized(lastPoint);
|
||
|
||
Log.Information(
|
||
"实时曲线同步汇总：Stage={Stage}, TestNumber={TestNumber}, DataPointCount={DataPointCount}, ChartCounts=[Vertical:{VerticalCount}, Friction:{FrictionCount}, Coefficient:{CoefficientCount}, DisplacementLine:{DisplacementCount}], DisplacementMode=零点到真实端点直线, CountsMatch={CountsMatch}, LastDataPoint={LastDataPoint}, ChartLast=[Vertical:{VerticalChart}, Friction:{FrictionChart}, Coefficient:{CoefficientChart}, DisplacementEndpoint:{DisplacementChart}]",
|
||
stage,
|
||
TestNumber,
|
||
expectedCount,
|
||
verticalLoadPoints.Count,
|
||
horizontalFrictionPoints.Count,
|
||
frictionCoefficientPoints.Count,
|
||
displacementPoints.Count,
|
||
countsMatch,
|
||
FormatDataPoint(lastPoint),
|
||
FormatChartPoint(verticalLoadPoints.Count > 0 ? verticalLoadPoints[^1] : null),
|
||
FormatChartPoint(horizontalFrictionPoints.Count > 0 ? horizontalFrictionPoints[^1] : null),
|
||
FormatChartPoint(frictionCoefficientPoints.Count > 0 ? frictionCoefficientPoints[^1] : null),
|
||
FormatChartPoint(displacementPoints.Count > 0 ? displacementPoints[^1] : null));
|
||
}
|
||
|
||
private void TraceRealtimeCurvePoint(SlipDataPoint point)
|
||
{
|
||
var expectedCount = currentRun.Count;
|
||
var countsMatch =
|
||
verticalLoadPoints.Count == expectedCount
|
||
&& horizontalFrictionPoints.Count == expectedCount
|
||
&& frictionCoefficientPoints.Count == expectedCount
|
||
&& IsLinearDisplacementSeriesSynchronized(point);
|
||
var valuesMatch =
|
||
countsMatch
|
||
&& ChartPointMatches(verticalLoadPoints[^1], point.TimeSeconds, point.VerticalLoadN)
|
||
&& ChartPointMatches(horizontalFrictionPoints[^1], point.TimeSeconds, point.HorizontalFrictionN)
|
||
&& ChartPointMatches(frictionCoefficientPoints[^1], point.TimeSeconds, point.FrictionCoefficient)
|
||
&& ChartPointMatches(displacementPoints[^1], point.TimeSeconds, point.DisplacementMm);
|
||
|
||
if (!countsMatch || !valuesMatch)
|
||
{
|
||
Log.Warning(
|
||
"实时曲线数据不同步：TestNumber={TestNumber}, PointIndex={PointIndex}, ExpectedCount={ExpectedCount}, Counts=[Vertical:{VerticalCount}, Friction:{FrictionCount}, Coefficient:{CoefficientCount}, DisplacementLine:{DisplacementCount}], DisplacementMode=零点到真实端点直线, ValuesMatch={ValuesMatch}, DataPoint=[Time:{Time:F3}s, Vertical:{Vertical:F3}N, Friction:{Friction:F3}N, Coefficient:{Coefficient:F5}, Displacement:{Displacement:F3}mm], ChartLast=[Vertical:{VerticalChart}, Friction:{FrictionChart}, Coefficient:{CoefficientChart}, DisplacementEndpoint:{DisplacementChart}]",
|
||
TestNumber,
|
||
expectedCount,
|
||
expectedCount,
|
||
verticalLoadPoints.Count,
|
||
horizontalFrictionPoints.Count,
|
||
frictionCoefficientPoints.Count,
|
||
displacementPoints.Count,
|
||
valuesMatch,
|
||
point.TimeSeconds,
|
||
point.VerticalLoadN,
|
||
point.HorizontalFrictionN,
|
||
point.FrictionCoefficient,
|
||
point.DisplacementMm,
|
||
FormatChartPoint(verticalLoadPoints.Count > 0 ? verticalLoadPoints[^1] : null),
|
||
FormatChartPoint(horizontalFrictionPoints.Count > 0 ? horizontalFrictionPoints[^1] : null),
|
||
FormatChartPoint(frictionCoefficientPoints.Count > 0 ? frictionCoefficientPoints[^1] : null),
|
||
FormatChartPoint(displacementPoints.Count > 0 ? displacementPoints[^1] : null));
|
||
return;
|
||
}
|
||
|
||
var now = DateTime.UtcNow;
|
||
if (expectedCount > 3 && now - lastRealtimeCurveTraceLoggedAt < RealtimeCurveTraceInterval)
|
||
{
|
||
return;
|
||
}
|
||
|
||
lastRealtimeCurveTraceLoggedAt = now;
|
||
Log.Debug(
|
||
"实时曲线点同步：TestNumber={TestNumber}, PointIndex={PointIndex}, Time={Time:F3}s, StandardTime={StandardTime}, Vertical={Vertical:F3}N, Friction={Friction:F3}N, Coefficient={Coefficient:F5}, Displacement={Displacement:F3}mm, InDynamicWindow={InDynamicWindow}, ChartCount={ChartCount}",
|
||
TestNumber,
|
||
expectedCount,
|
||
point.TimeSeconds,
|
||
FormatStandardTime(point),
|
||
point.VerticalLoadN,
|
||
point.HorizontalFrictionN,
|
||
point.FrictionCoefficient,
|
||
point.DisplacementMm,
|
||
IsInDynamicWindow(point),
|
||
expectedCount);
|
||
}
|
||
|
||
private void UpdateLinearDisplacementSeries(SlipDataPoint endpoint)
|
||
{
|
||
if (displacementPoints.Count == 0)
|
||
{
|
||
displacementPoints.Add(new ObservablePoint(0, 0));
|
||
}
|
||
|
||
if (endpoint.TimeSeconds <= 0.000001)
|
||
{
|
||
while (displacementPoints.Count > 1)
|
||
{
|
||
displacementPoints.RemoveAt(displacementPoints.Count - 1);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
var endpointPoint = new ObservablePoint(endpoint.TimeSeconds, endpoint.DisplacementMm);
|
||
if (displacementPoints.Count == 1)
|
||
{
|
||
displacementPoints.Add(endpointPoint);
|
||
}
|
||
else
|
||
{
|
||
displacementPoints[1] = endpointPoint;
|
||
}
|
||
|
||
while (displacementPoints.Count > 2)
|
||
{
|
||
displacementPoints.RemoveAt(displacementPoints.Count - 1);
|
||
}
|
||
}
|
||
|
||
private bool IsLinearDisplacementSeriesSynchronized(SlipDataPoint? endpoint)
|
||
{
|
||
if (endpoint is null)
|
||
{
|
||
return displacementPoints.Count == 0;
|
||
}
|
||
|
||
var expectedCount = endpoint.TimeSeconds <= 0.000001 ? 1 : 2;
|
||
return displacementPoints.Count == expectedCount
|
||
&& ChartPointMatches(displacementPoints[0], 0, 0)
|
||
&& (expectedCount == 1
|
||
|| ChartPointMatches(displacementPoints[^1], endpoint.TimeSeconds, endpoint.DisplacementMm));
|
||
}
|
||
|
||
private static bool ChartPointMatches(ObservablePoint chartPoint, double expectedX, double expectedY) =>
|
||
NearlyEquals(chartPoint.X, expectedX) && NearlyEquals(chartPoint.Y, expectedY);
|
||
|
||
private static bool NearlyEquals(double? actual, double expected) =>
|
||
actual.HasValue && Math.Abs(actual.Value - expected) < 0.000001;
|
||
|
||
private static string FormatChartPoint(ObservablePoint? point) =>
|
||
point is null
|
||
? "null"
|
||
: $"({FormatNullable(point.X)},{FormatNullable(point.Y)})";
|
||
|
||
private static string FormatNullable(double? value) =>
|
||
value.HasValue ? value.Value.ToString("F3", CultureInfo.InvariantCulture) : "null";
|
||
|
||
private static string FormatStandardTime(SlipDataPoint? point) =>
|
||
point is null ? "null" : point.TimeSeconds.ToString("F3", CultureInfo.InvariantCulture);
|
||
|
||
private static bool IsInDynamicWindow(SlipDataPoint point) =>
|
||
point.TimeSeconds >= DynamicWindowStartSeconds && point.TimeSeconds <= DynamicWindowEndSeconds;
|
||
|
||
private static string FormatDataPoint(SlipDataPoint? point) =>
|
||
point is null
|
||
? "null"
|
||
: $"StandardTime={point.TimeSeconds.ToString("F3", CultureInfo.InvariantCulture)}s, Vertical={point.VerticalLoadN.ToString("F3", CultureInfo.InvariantCulture)}N, Friction={point.HorizontalFrictionN.ToString("F3", CultureInfo.InvariantCulture)}N, Coefficient={point.FrictionCoefficient.ToString("F5", CultureInfo.InvariantCulture)}, SlidingDisplacement={point.DisplacementMm.ToString("F3", CultureInfo.InvariantCulture)}mm";
|
||
|
||
private async Task RunDeviceCommand(Task command, string successMessage)
|
||
{
|
||
try
|
||
{
|
||
await command;
|
||
CurrentStatus = successMessage;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Log.Error(ex, "设备指令失败：{SuccessMessage}", successMessage);
|
||
CurrentStatus = $"设备指令失败：{ex.Message}";
|
||
}
|
||
}
|
||
|
||
private Task RunLicensedDeviceCommand(Func<Task> command, string successMessage)
|
||
{
|
||
if (isLicenseLockPending)
|
||
{
|
||
CurrentStatus = "软件使用时效已到，仅允许停止或复位设备。";
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
return RunDeviceCommand(command(), successMessage);
|
||
}
|
||
|
||
private void WriteNumericSetting(string value, Func<double, Task> writer, string label)
|
||
{
|
||
if (isLoadingDeviceSettings || !TryParseDouble(value, out var numericValue))
|
||
{
|
||
return;
|
||
}
|
||
|
||
_ = RunDeviceCommand(writer(numericValue), $"{label}已写入 PLC");
|
||
}
|
||
|
||
private void SaveAndApplySettings()
|
||
{
|
||
SaveDeviceSettings();
|
||
deviceService.UpdateSettings(CurrentSettings());
|
||
}
|
||
|
||
private void ApplyConnectionSettings()
|
||
{
|
||
var settings = CurrentSettings();
|
||
if (ConnectionSettingsChanged(settings))
|
||
{
|
||
RestartDeviceConnection(settings);
|
||
return;
|
||
}
|
||
|
||
deviceService.UpdateSettings(settings);
|
||
}
|
||
|
||
private bool ConnectionSettingsChanged(DeviceSettings settings) =>
|
||
!string.Equals(activePlcPortName, settings.PlcPortName, StringComparison.OrdinalIgnoreCase)
|
||
|| !string.Equals(activeAdcPortName, settings.AdcPortName, StringComparison.OrdinalIgnoreCase)
|
||
|| activeBaudRate != settings.BaudRate;
|
||
|
||
private void RestartDeviceConnection()
|
||
{
|
||
RestartDeviceConnection(CurrentSettings());
|
||
}
|
||
|
||
private void RestartDeviceConnection(DeviceSettings settings)
|
||
{
|
||
deviceService.Start(settings);
|
||
activePlcPortName = settings.PlcPortName;
|
||
activeAdcPortName = settings.AdcPortName;
|
||
activeBaudRate = settings.BaudRate;
|
||
}
|
||
|
||
private bool ValidateAdcCoefficientsBeforeTest()
|
||
{
|
||
var invalid = new List<string>();
|
||
AddInvalidCoefficient(NormalPressureCoefficient, "正压力校准系数", invalid);
|
||
AddInvalidCoefficient(FrictionCoefficient1, "摩擦1校准系数", invalid);
|
||
AddInvalidCoefficient(FrictionCoefficient2, "摩擦2校准系数", invalid);
|
||
|
||
if (invalid.Count == 0)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
var message = "ADC 校准系数无效：" + string.Join("、", invalid) + "；请填写旧机实际标定系数后再开始测试";
|
||
Log.Warning("阻止测试启动：{Message}", message);
|
||
CurrentStatus = message;
|
||
return false;
|
||
}
|
||
|
||
private async Task LoadPlcParametersAsync()
|
||
{
|
||
try
|
||
{
|
||
var parameters = await deviceService.ReadDeviceParametersAsync();
|
||
isLoadingDeviceSettings = true;
|
||
ManualSpeed = parameters.ManualSpeed.ToString("F2", CultureInfo.InvariantCulture);
|
||
ManualDisplacement = parameters.ManualDisplacement.ToString("F2", CultureInfo.InvariantCulture);
|
||
TestSpeed = parameters.TestSpeed.ToString("F2", CultureInfo.InvariantCulture);
|
||
isLoadingDeviceSettings = false;
|
||
SaveAndApplySettings();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
isLoadingDeviceSettings = false;
|
||
Log.Warning(ex, "启动时读取 PLC 参数失败，将使用本地保存的设备设置");
|
||
}
|
||
}
|
||
|
||
private void LoadDeviceSettings()
|
||
{
|
||
if (!File.Exists(DeviceSettingsPath))
|
||
{
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
var json = File.ReadAllText(DeviceSettingsPath);
|
||
var settings = JsonSerializer.Deserialize<DeviceSettings>(json);
|
||
if (settings is null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
isLoadingDeviceSettings = true;
|
||
ManualSpeed = settings.ManualSpeed ?? ManualSpeed;
|
||
ManualDisplacement = settings.ManualDisplacement ?? ManualDisplacement;
|
||
TestSpeed = settings.TestSpeed ?? TestSpeed;
|
||
NormalPressureZero = settings.NormalPressureZero ?? NormalPressureZero;
|
||
NormalPressureCoefficient = settings.NormalPressureCoefficient ?? NormalPressureCoefficient;
|
||
FrictionZero1 = settings.FrictionZero1 ?? FrictionZero1;
|
||
FrictionCoefficient1 = settings.FrictionCoefficient1 ?? FrictionCoefficient1;
|
||
FrictionZero2 = settings.FrictionZero2 ?? FrictionZero2;
|
||
FrictionCoefficient2 = settings.FrictionCoefficient2 ?? FrictionCoefficient2;
|
||
PlcPortName = NormalizeSavedPort(settings.PlcPortName, DefaultPlcPortName, LegacyPlcPortName);
|
||
AdcPortName = NormalizeSavedPort(settings.AdcPortName, DefaultAdcPortName, LegacyAdcPortName);
|
||
BaudRate = settings.BaudRate > 0 ? settings.BaudRate : BaudRate;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Log.Warning(ex, "读取设备设置失败：Path={Path}", DeviceSettingsPath);
|
||
}
|
||
finally
|
||
{
|
||
isLoadingDeviceSettings = false;
|
||
}
|
||
}
|
||
|
||
private void SaveDeviceSettings()
|
||
{
|
||
if (isLoadingDeviceSettings)
|
||
{
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
Directory.CreateDirectory(Path.GetDirectoryName(DeviceSettingsPath)!);
|
||
var json = JsonSerializer.Serialize(CurrentSettings(), new JsonSerializerOptions { WriteIndented = true });
|
||
File.WriteAllText(DeviceSettingsPath, json);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Log.Warning(ex, "保存设备设置失败：Path={Path}", DeviceSettingsPath);
|
||
}
|
||
}
|
||
|
||
private DeviceSettings CurrentSettings() =>
|
||
new(
|
||
ManualSpeed,
|
||
ManualDisplacement,
|
||
TestSpeed,
|
||
NormalPressureZero,
|
||
NormalPressureCoefficient,
|
||
FrictionZero1,
|
||
FrictionCoefficient1,
|
||
FrictionZero2,
|
||
FrictionCoefficient2,
|
||
PlcPortName,
|
||
AdcPortName,
|
||
BaudRate);
|
||
|
||
private void UpdateTargetLoad()
|
||
{
|
||
TargetLoadText = SelectedShoeSizeIndex switch
|
||
{
|
||
1 => "350 N",
|
||
2 => "160 N",
|
||
_ => "400 N"
|
||
};
|
||
}
|
||
|
||
private string CurrentShoeSize() => SelectedShoeSizeIndex switch
|
||
{
|
||
1 => "205-250",
|
||
2 => "205以下",
|
||
_ => "250(含)以上"
|
||
};
|
||
|
||
private string CurrentLubricant() => CurrentLubricant(SelectedLubricantIndex);
|
||
|
||
private static string CurrentLubricant(int lubricantIndex) => lubricantIndex switch
|
||
{
|
||
1 => "湿态 - 蒸馏水",
|
||
2 => "湿态 - 洗涤剂",
|
||
3 => "冰霜",
|
||
_ => "干态"
|
||
};
|
||
|
||
private string CurrentMode() => SelectedModeIndex switch
|
||
{
|
||
0 => "后跟测试模式",
|
||
1 => "前掌测试模式",
|
||
_ => "水平测试模式"
|
||
};
|
||
|
||
private string CurrentSurface() => SelectedSurfaceIndex switch
|
||
{
|
||
1 => "木地板",
|
||
2 => "石材",
|
||
3 => "冰霜表面",
|
||
_ => "瓷砖"
|
||
};
|
||
|
||
private static bool TryParseDouble(string value, out double numericValue) =>
|
||
double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out numericValue)
|
||
|| double.TryParse(value, NumberStyles.Float, CultureInfo.CurrentCulture, out numericValue);
|
||
|
||
private static void AddInvalidCoefficient(string value, string label, List<string> invalid)
|
||
{
|
||
if (!TryParseDouble(value, out var coefficient) || Math.Abs(coefficient) < 0.0001)
|
||
{
|
||
invalid.Add($"{label}={value}");
|
||
}
|
||
}
|
||
|
||
private static bool IsAdcCalibrationError(string error) =>
|
||
error.Contains("ADC 校准参数无效", StringComparison.Ordinal);
|
||
|
||
private static string NormalizeSavedPort(string? savedPort, string defaultPort, string legacyPort)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(savedPort) || string.Equals(savedPort, legacyPort, StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
return defaultPort;
|
||
}
|
||
|
||
return savedPort;
|
||
}
|
||
|
||
private static LineSeries<ObservablePoint> CreateLineSeries(
|
||
string name,
|
||
ObservableCollection<ObservablePoint> values,
|
||
string color,
|
||
int yAxis) =>
|
||
new()
|
||
{
|
||
Name = name,
|
||
Values = values,
|
||
MiniatureShapeSize = 8,
|
||
MiniatureStrokeThickness = 1.6f,
|
||
Stroke = new SolidColorPaint(SKColor.Parse(color)) { StrokeThickness = 1.7f },
|
||
Fill = new SolidColorPaint(SKColors.Transparent),
|
||
GeometryFill = null,
|
||
GeometryStroke = null,
|
||
GeometrySize = 0,
|
||
LineSmoothness = 0,
|
||
ScalesYAt = yAxis
|
||
};
|
||
|
||
private static string DeviceSettingsPath =>
|
||
Path.Combine(
|
||
Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
|
||
"FootwearSlipResistance",
|
||
"device-settings.json");
|
||
}
|
||
}
|