498 lines
19 KiB
C#
498 lines
19 KiB
C#
using System;
|
||
using System.Collections.ObjectModel;
|
||
using System.Threading;
|
||
using System.Threading.Tasks;
|
||
using System.Windows;
|
||
using CommunityToolkit.Mvvm.ComponentModel;
|
||
using CommunityToolkit.Mvvm.Input;
|
||
using AciTester.Models;
|
||
using AciTester.Services;
|
||
|
||
namespace AciTester.ViewModels
|
||
{
|
||
public partial class MainViewModel : ObservableObject
|
||
{
|
||
public readonly IPlcService _plcService;
|
||
private readonly IReportService _reportService;
|
||
public readonly PlcConfiguration _config;
|
||
private CancellationTokenSource _testCts;
|
||
private bool _alarmShownLow = false;
|
||
private bool _alarmShownHigh = false;
|
||
public IAsyncRelayCommand OpenValveCommand { get; }
|
||
[ObservableProperty]
|
||
private bool isConnected;
|
||
|
||
[ObservableProperty]
|
||
private string connectionStatus = "未连接";
|
||
|
||
[ObservableProperty]
|
||
private float currentFlow;
|
||
|
||
[ObservableProperty]
|
||
private bool isPumpRunning;
|
||
|
||
[ObservableProperty]
|
||
private bool isTesting;
|
||
|
||
[ObservableProperty]
|
||
private bool canStopTest; // 控制“停止测试”按钮的启用状态
|
||
|
||
[ObservableProperty]
|
||
private int sampleTimeSeconds = 60;
|
||
|
||
[ObservableProperty]
|
||
private int remainingSeconds;
|
||
|
||
[ObservableProperty]
|
||
private ObservableCollection<StageData> stages;
|
||
|
||
[ObservableProperty]
|
||
private TestResult currentResult;
|
||
|
||
[ObservableProperty]
|
||
private RealTimeData realTime;
|
||
|
||
[ObservableProperty]
|
||
private CalibrationConfig calibration;
|
||
|
||
[ObservableProperty]
|
||
private bool constantTempStartEnabled = true; // 是否允许恒温启动（除霜时为false）
|
||
|
||
public IAsyncRelayCommand StartPumpCommand { get; }
|
||
public IAsyncRelayCommand StopPumpCommand { get; }
|
||
// 阀门/泵状态（用于界面显示）
|
||
[ObservableProperty]
|
||
private bool valveStatus; // true=开启, false=关闭
|
||
|
||
[ObservableProperty]
|
||
private bool pumpStatus; // true=运行, false=停止
|
||
|
||
public IAsyncRelayCommand CloseValveCommand { get; }
|
||
|
||
public MainViewModel()
|
||
{
|
||
_config = new PlcConfiguration();
|
||
_plcService = new ModbusTcpPlcService(_config);
|
||
_reportService = new ExcelReportService();
|
||
|
||
Stages = new ObservableCollection<StageData>
|
||
{
|
||
new StageData { StageName = "Stage 0", CutoffDiameter = 9.0 },
|
||
new StageData { StageName = "Stage 1", CutoffDiameter = 5.8 },
|
||
new StageData { StageName = "Stage 2", CutoffDiameter = 4.7 },
|
||
new StageData { StageName = "Stage 3", CutoffDiameter = 3.3 },
|
||
new StageData { StageName = "Stage 4", CutoffDiameter = 2.1 },
|
||
new StageData { StageName = "Stage 5", CutoffDiameter = 1.1 },
|
||
new StageData { StageName = "Stage 6", CutoffDiameter = 0.7 },
|
||
new StageData { StageName = "Stage 7", CutoffDiameter = 0.4 },
|
||
new StageData { StageName = "Filter", CutoffDiameter = 0.0 }
|
||
};
|
||
|
||
ConnectCommand = new AsyncRelayCommand(ConnectAsync);
|
||
DisconnectCommand = new RelayCommand(Disconnect);
|
||
StartTestCommand = new AsyncRelayCommand(StartTestAsync);
|
||
StopTestCommand = new AsyncRelayCommand(StopTestAsync, () => IsTesting);
|
||
CalculateCommand = new RelayCommand(CalculateResult);
|
||
ExportReportCommand = new AsyncRelayCommand(ExportReportAsync);
|
||
|
||
// 写入命令
|
||
WriteConstantTempStartCommand = new AsyncRelayCommand<bool>(WriteConstantTempStartAsync);
|
||
WriteDefrostStartCommand = new AsyncRelayCommand<bool>(WriteDefrostStartAsync);
|
||
WriteDefrostTempSetCommand = new AsyncRelayCommand<float>(WriteDefrostTempSetAsync);
|
||
WriteDefrostTimeSetCommand = new AsyncRelayCommand<int>(WriteDefrostTimeSetAsync);
|
||
|
||
RealTime = new RealTimeData();
|
||
Calibration = new CalibrationConfig();
|
||
OpenValveCommand = new AsyncRelayCommand(async () =>
|
||
{
|
||
await _plcService.WriteCoilAsync(_config.ValveCoil, true);
|
||
ValveStatus = true;
|
||
});
|
||
CloseValveCommand = new AsyncRelayCommand(async () =>
|
||
{
|
||
await _plcService.WriteCoilAsync(_config.ValveCoil, false);
|
||
ValveStatus = false;
|
||
});
|
||
|
||
StartPumpCommand = new AsyncRelayCommand(async () =>
|
||
{
|
||
await _plcService.WriteCoilAsync(_config.PumpCoil, true);
|
||
PumpStatus = true;
|
||
});
|
||
StopPumpCommand = new AsyncRelayCommand(async () =>
|
||
{
|
||
await _plcService.WriteCoilAsync(_config.PumpCoil, false);
|
||
PumpStatus = false;
|
||
});
|
||
|
||
|
||
// 监听属性变化，当除霜启动时更新恒温启动使能
|
||
RealTime.PropertyChanged += async (s, e) =>
|
||
{
|
||
if (e.PropertyName == nameof(RealTime.DefrostTempSet))
|
||
{
|
||
await WriteDefrostTempSetAsync(RealTime.DefrostTempSet);
|
||
}
|
||
else if (e.PropertyName == nameof(RealTime.DefrostTimeSet))
|
||
{
|
||
await WriteDefrostTimeSetAsync(RealTime.DefrostTimeSet);
|
||
}
|
||
};
|
||
|
||
}
|
||
public IAsyncRelayCommand StopTestCommand { get; }
|
||
public IAsyncRelayCommand ConnectCommand { get; }
|
||
public IRelayCommand DisconnectCommand { get; }
|
||
public IAsyncRelayCommand StartTestCommand { get; }
|
||
public IRelayCommand CalculateCommand { get; }
|
||
public IAsyncRelayCommand ExportReportCommand { get; }
|
||
public IAsyncRelayCommand<bool> WriteConstantTempStartCommand { get; }
|
||
public IAsyncRelayCommand<bool> WriteDefrostStartCommand { get; }
|
||
public IAsyncRelayCommand<float> WriteDefrostTempSetCommand { get; }
|
||
public IAsyncRelayCommand<int> WriteDefrostTimeSetCommand { get; }
|
||
|
||
private async Task StopTestAsync()
|
||
{
|
||
if (!IsTesting) return;
|
||
|
||
try
|
||
{
|
||
// 停止真空泵
|
||
await _plcService.WriteCoilAsync(_config.PumpCoil, false);
|
||
IsPumpRunning = false;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
MessageBox.Show($"停止泵失败: {ex.Message}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
|
||
}
|
||
finally
|
||
{
|
||
// 重置状态
|
||
IsTesting = false;
|
||
CanStopTest = false;
|
||
_testCts?.Cancel(); // 取消倒计时
|
||
|
||
RemainingSeconds = 0;
|
||
|
||
// 更新按钮状态
|
||
StopTestCommand.NotifyCanExecuteChanged();
|
||
}
|
||
|
||
//MessageBox.Show("测试已手动停止，请进行称重并录入数据。", "提示", MessageBoxButton.OK, MessageBoxImage.Information);
|
||
}
|
||
|
||
|
||
|
||
private async Task ConnectAsync()
|
||
{
|
||
try
|
||
{
|
||
await _plcService.EnsureConnectedAsync();
|
||
IsConnected = true;
|
||
ConnectionStatus = "已连接";
|
||
_ = Task.Run(ReadFlowLoop);
|
||
_ = Task.Run(ReadRealTimeLoop);
|
||
_ = Task.Run(ReadAlarmLoop); // 报警循环
|
||
_ = Task.Run(ReadDefrostStatusLoop); // 除霜相关状态
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
MessageBox.Show($"连接失败: {ex.Message}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
|
||
IsConnected = false;
|
||
ConnectionStatus = "连接失败";
|
||
}
|
||
}
|
||
|
||
private void Disconnect()
|
||
{
|
||
_plcService.Dispose();
|
||
IsConnected = false;
|
||
ConnectionStatus = "未连接";
|
||
}
|
||
|
||
private async Task ReadFlowLoop()
|
||
{
|
||
while (IsConnected)
|
||
{
|
||
try
|
||
{
|
||
var flow = await _plcService.ReadFloatAsync(_config.FlowRegister);
|
||
Application.Current.Dispatcher.Invoke(() => CurrentFlow = flow);
|
||
await Task.Delay(1000);
|
||
}
|
||
catch { break; }
|
||
}
|
||
}
|
||
|
||
private async Task ReadRealTimeLoop()
|
||
{
|
||
while (IsConnected)
|
||
{
|
||
try
|
||
{
|
||
var rawFlow = await _plcService.ReadFloatAsync(_config.FlowRegister);
|
||
var calibrated = rawFlow * Calibration.FlowCalibration;
|
||
var temp = await _plcService.ReadFloatAsync(_config.TemperatureReg);
|
||
var calibratedTemp = temp * Calibration.TemperatureCalibration;
|
||
var pumpPres = await _plcService.ReadFloatAsync(_config.PumpPressureReg);
|
||
var calibratedPump = pumpPres * Calibration.PumpPressureCalibration;
|
||
var impPres = await _plcService.ReadFloatAsync(_config.ImpactorPressureReg);
|
||
var calibratedImp = impPres * Calibration.ImpactorPressureCalibration;
|
||
|
||
Application.Current.Dispatcher.Invoke(() =>
|
||
{
|
||
RealTime.RawFlow = rawFlow;
|
||
RealTime.CalibratedFlow = calibrated;
|
||
RealTime.Temperature = calibratedTemp;
|
||
RealTime.PumpPressure = calibratedPump;
|
||
RealTime.ImpactorPressure = calibratedImp;
|
||
RealTime.DifferentialPressure = calibratedImp - calibratedPump;
|
||
});
|
||
|
||
// 在 ReadRealTimeLoop 中添加
|
||
var valve = await _plcService.ReadCoilAsync(_config.ValveCoil);
|
||
var pump = await _plcService.ReadCoilAsync(_config.PumpCoil);
|
||
Application.Current.Dispatcher.Invoke(() =>
|
||
{
|
||
ValveStatus = valve;
|
||
PumpStatus = pump;
|
||
});
|
||
|
||
|
||
|
||
if (calibrated < Calibration.FlowLowLimit || calibrated > Calibration.FlowHighLimit)
|
||
{
|
||
//Application.Current.Dispatcher.Invoke(() =>
|
||
// MessageBox.Show($"流量异常: {calibrated:F2} L/min", "警告", MessageBoxButton.OK, MessageBoxImage.Warning));
|
||
}
|
||
}
|
||
catch { }
|
||
await Task.Delay(1000);
|
||
}
|
||
}
|
||
|
||
private async Task ReadAlarmLoop()
|
||
{
|
||
while (IsConnected)
|
||
{
|
||
try
|
||
{
|
||
var lowAlarm = await _plcService.ReadCoilAsync(_config.AcLowPressureAlarmCoil);
|
||
var highAlarm = await _plcService.ReadCoilAsync(_config.AcHighPressureAlarmCoil);
|
||
|
||
Application.Current.Dispatcher.Invoke(() =>
|
||
{
|
||
RealTime.AcLowPressureAlarm = lowAlarm;
|
||
RealTime.AcHighPressureAlarm = highAlarm;
|
||
});
|
||
|
||
if (lowAlarm && !_alarmShownLow)
|
||
{
|
||
_alarmShownLow = true;
|
||
Application.Current.Dispatcher.Invoke(() =>
|
||
{
|
||
var result = MessageBox.Show("空调低压报警，请检查空调情况", "报警", MessageBoxButton.OK, MessageBoxImage.Error);
|
||
if (result == MessageBoxResult.OK)
|
||
{
|
||
_ = _plcService.WriteCoilAsync(_config.AcLowPressureAlarmCoil, false);
|
||
_alarmShownLow = false;
|
||
}
|
||
});
|
||
}
|
||
if (highAlarm && !_alarmShownHigh)
|
||
{
|
||
_alarmShownHigh = true;
|
||
Application.Current.Dispatcher.Invoke(() =>
|
||
{
|
||
var result = MessageBox.Show("空调高压报警，请检查空调情况", "报警", MessageBoxButton.OK, MessageBoxImage.Error);
|
||
if (result == MessageBoxResult.OK)
|
||
{
|
||
_ = _plcService.WriteCoilAsync(_config.AcHighPressureAlarmCoil, false);
|
||
_alarmShownHigh = false;
|
||
}
|
||
});
|
||
}
|
||
}
|
||
catch { }
|
||
await Task.Delay(500);
|
||
}
|
||
}
|
||
|
||
private async Task ReadDefrostStatusLoop()
|
||
{
|
||
while (IsConnected)
|
||
{
|
||
try
|
||
{
|
||
// 读取 D50 空调启动倒计时
|
||
var countdown = await _plcService.ReadInt32Async(_config.AcStartupCountdownReg);
|
||
// 读取 D302 除霜温度设置
|
||
var defrostTemp = await _plcService.ReadFloatAsync(_config.DefrostTempSetReg);
|
||
// 读取 D310 除霜时间设置
|
||
var defrostTime = await _plcService.ReadInt32Async(_config.DefrostTimeSetReg);
|
||
// 读取 D42 D40 除霜计时
|
||
var min = await _plcService.ReadInt32Async(_config.DefrostMinuteReg);
|
||
var sec = await _plcService.ReadInt32Async(_config.DefrostSecondReg);
|
||
// 读取 M4 M19
|
||
var constTemp = await _plcService.ReadCoilAsync(_config.ConstantTempStartCoil);
|
||
var defrostStart = await _plcService.ReadCoilAsync(_config.DefrostStartCoil);
|
||
|
||
Application.Current.Dispatcher.Invoke(() =>
|
||
{
|
||
RealTime.AcStartupCountdown = countdown;
|
||
RealTime.DefrostTempSet = defrostTemp;
|
||
RealTime.DefrostTimeSet = defrostTime;
|
||
RealTime.DefrostMinute = min;
|
||
RealTime.DefrostSecond = sec;
|
||
RealTime.ConstantTempStart = constTemp;
|
||
RealTime.DefrostStart = defrostStart;
|
||
});
|
||
}
|
||
catch { }
|
||
await Task.Delay(1000);
|
||
}
|
||
}
|
||
|
||
private async Task WriteConstantTempStartAsync(bool value)
|
||
{
|
||
if (!IsConnected) return;
|
||
if (RealTime.DefrostStart)
|
||
{
|
||
MessageBox.Show("设备正在除霜，不能进行恒温操作", "提示", MessageBoxButton.OK, MessageBoxImage.Warning);
|
||
return;
|
||
}
|
||
await _plcService.WriteCoilAsync(_config.ConstantTempStartCoil, value);
|
||
}
|
||
|
||
private async Task WriteDefrostStartAsync(bool value)
|
||
{
|
||
if (!IsConnected) return;
|
||
await _plcService.WriteCoilAsync(_config.DefrostStartCoil, value);
|
||
if (value)
|
||
{
|
||
// 立即更新界面使能
|
||
ConstantTempStartEnabled = false;
|
||
}
|
||
else
|
||
{
|
||
ConstantTempStartEnabled = true;
|
||
}
|
||
}
|
||
|
||
private async Task WriteDefrostTempSetAsync(float value)
|
||
{
|
||
if (!IsConnected) return;
|
||
await _plcService.WriteMultipleRegistersAsync(_config.DefrostTempSetReg, value);
|
||
}
|
||
|
||
private async Task WriteDefrostTimeSetAsync(int value)
|
||
{
|
||
if (!IsConnected) return;
|
||
await _plcService.WriteInt32Async(_config.DefrostTimeSetReg, value);
|
||
}
|
||
|
||
private async Task StartTestAsync()
|
||
{
|
||
if (!IsConnected)
|
||
{
|
||
await ConnectAsync();
|
||
if (!IsConnected) return;
|
||
}
|
||
|
||
if (IsTesting) return;
|
||
|
||
IsTesting = true;
|
||
_testCts = new CancellationTokenSource();
|
||
//StopTestCommand.NotifyCanExecuteChanged();
|
||
try
|
||
{
|
||
await _plcService.WriteCoilAsync(_config.PumpCoil, true);
|
||
IsPumpRunning = true;
|
||
|
||
RemainingSeconds = SampleTimeSeconds;
|
||
for (int i = 0; i < SampleTimeSeconds; i++)
|
||
{
|
||
if (_testCts.Token.IsCancellationRequested) break;
|
||
await Task.Delay(1000);
|
||
RemainingSeconds--;
|
||
}
|
||
|
||
await _plcService.WriteCoilAsync(_config.PumpCoil, false);
|
||
IsPumpRunning = false;
|
||
|
||
MessageBox.Show($"采样完成！\n实际采样时间: {SampleTimeSeconds} 秒\n请进行称重并录入数据。",
|
||
"提示", MessageBoxButton.OK, MessageBoxImage.Information);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
MessageBox.Show($"测试异常: {ex.Message}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
|
||
try { await _plcService.WriteCoilAsync(_config.PumpCoil, false); } catch { }
|
||
IsPumpRunning = false;
|
||
}
|
||
finally
|
||
{
|
||
IsTesting = false;
|
||
_testCts?.Dispose();
|
||
}
|
||
}
|
||
|
||
private void CalculateResult()
|
||
{
|
||
double totalMass = 0;
|
||
foreach (var stage in Stages)
|
||
totalMass += stage.NetWeight;
|
||
|
||
if (totalMass <= 0)
|
||
{
|
||
MessageBox.Show("总质量为零，无法计算", "警告", MessageBoxButton.OK, MessageBoxImage.Warning);
|
||
return;
|
||
}
|
||
|
||
double fineMass = 0;
|
||
foreach (var stage in Stages)
|
||
{
|
||
if (stage.CutoffDiameter <= 5.0 && stage.CutoffDiameter > 0)
|
||
fineMass += stage.NetWeight;
|
||
}
|
||
fineMass += Stages[8].NetWeight;
|
||
|
||
double fpd = fineMass * 1000;
|
||
double fpf = (fineMass / totalMass) * 100;
|
||
|
||
CurrentResult = new TestResult
|
||
{
|
||
TestTime = DateTime.Now,
|
||
TotalMass = totalMass,
|
||
FineParticleDose = fpd,
|
||
FineParticleFraction = fpf,
|
||
Stages = Stages.ToList(),
|
||
FlowRate = CurrentFlow,
|
||
Temperature = RealTime.Temperature,
|
||
DifferentialPressure = RealTime.DifferentialPressure
|
||
};
|
||
|
||
MessageBox.Show($"计算完成\n总质量: {totalMass:F4} g\n微细粒子剂量: {fpd:F2} mg\n微细粒子分数: {fpf:F2}%",
|
||
"计算结果", MessageBoxButton.OK, MessageBoxImage.Information);
|
||
}
|
||
|
||
private async Task ExportReportAsync()
|
||
{
|
||
if (CurrentResult == null)
|
||
{
|
||
MessageBox.Show("请先计算测试结果", "提示", MessageBoxButton.OK, MessageBoxImage.Information);
|
||
return;
|
||
}
|
||
|
||
var saveDialog = new Microsoft.Win32.SaveFileDialog
|
||
{
|
||
Filter = "Excel文件|*.xlsx",
|
||
FileName = $"ACI_Test_{DateTime.Now:yyyyMMdd_HHmmss}.xlsx"
|
||
};
|
||
if (saveDialog.ShowDialog() == true)
|
||
{
|
||
await _reportService.GenerateReportAsync(CurrentResult, saveDialog.FileName);
|
||
MessageBox.Show("报告已保存", "完成", MessageBoxButton.OK, MessageBoxImage.Information);
|
||
}
|
||
}
|
||
}
|
||
} |