418 lines
15 KiB
C#
418 lines
15 KiB
C#
using Aurora;
|
|
using Aurora.Api;
|
|
using Aurora.Api.Devices;
|
|
using Aurora.Api.Manager;
|
|
using Aurora.View;
|
|
using AuroraDeviceCommon.Views;
|
|
using AuroraMassFlowMeter;
|
|
using AuroraUIComponent.Chart;
|
|
using Hermes;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reactive.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Input;
|
|
using System.Windows.Threading;
|
|
|
|
namespace AuroraMassFlowMeter.MFC
|
|
{
|
|
public class UCMassFlowMeterDeviceViewModel : NotifyPropertyChangedBase
|
|
{
|
|
public ICommand CMD_WRITE_SET_POINT { get; }
|
|
public ICommand CMD_READ_SET_POINT { get; }
|
|
public ICommand CMD_READ_FLOW { get; }
|
|
public ICommand CMD_READ_READING_ERROR { get; }
|
|
public ICommand CMD_WRITE_READING_ERROR { get; }
|
|
public ICommand CMD_READ_MFC_STATUS { get; }
|
|
public ICommand CMD_WRITE_DEVICE_ID { get; }
|
|
public ICommand CMD_READ_DEVICE_ID { get; }
|
|
public ICommand CMD_READ_OPERATION_MODE { get; }
|
|
public ICommand CMD_WRITE_OPERATION_MODE { get; }
|
|
public ICommand CMD_READ_MODEL_NAME { get; }
|
|
public ICommand CMD_READ_FIRMWARE_REVISION { get; }
|
|
public ICommand CMD_READ_HARDWARE_REVISION { get; }
|
|
public ICommand CMD_READ_SERIAL { get; }
|
|
public ICommand CMD_READ_BAUD_RATE { get; }
|
|
public ICommand CMD_WRITE_BAUD_RATE { get; }
|
|
public ICommand CMD_READ_GAS_NAME { get; }
|
|
public ICommand CMD_READ_FULL_SCALE { get; }
|
|
public ICommand CMD_READ_FLOW_UNIT { get; }
|
|
public ICommand CMD_READ_INTEGRATION { get; }
|
|
public ICommand CMD_RESET_INTEGRATION { get; }
|
|
public ICommand CMD_READ_INTEGRATION_ON { get; }
|
|
public ICommand CMD_WRITE_INTEGRATION_ON { get; }
|
|
public ICommand CMD_WRITE_RAMP_SET_POINT { get; }
|
|
public ICommand CMD_ZERO_OFFSET { get; }
|
|
|
|
|
|
public ICommand CMD_VisibleChanged { get; }
|
|
|
|
|
|
private readonly DispatcherTimer MonitorTimer;
|
|
|
|
private double _WriteSetPoint;
|
|
public double WriteSetPoint { get => _WriteSetPoint; set => SetProperty(ref _WriteSetPoint, value); }
|
|
|
|
private double _ReadSetPoint;
|
|
public double ReadSetPoint { get => _ReadSetPoint; set => SetProperty(ref _ReadSetPoint, value); }
|
|
|
|
private double _ReadFlow;
|
|
public double ReadFlow { get => _ReadFlow; set => SetProperty(ref _ReadFlow, value); }
|
|
|
|
private double _ReadReadingError;
|
|
public double ReadReadingError { get => _ReadReadingError; set => SetProperty(ref _ReadReadingError, value); }
|
|
|
|
private double _WriteReadingError;
|
|
public double WriteReadingError { get => _WriteReadingError; set => SetProperty(ref _WriteReadingError, value); }
|
|
|
|
private int _ReadMFCStatus;
|
|
public int ReadMFCStatus { get => _ReadMFCStatus; set => SetProperty(ref _ReadMFCStatus, value); }
|
|
|
|
private int _WriteDeviceID;
|
|
public int WriteDeviceID { get => _WriteDeviceID; set => SetProperty(ref _WriteDeviceID, value); }
|
|
|
|
private int _ReadDeviceID;
|
|
public int ReadDeviceID { get => _ReadDeviceID; set => SetProperty(ref _ReadDeviceID, value); }
|
|
|
|
private int _ReadOperationMode;
|
|
public int ReadOperationMode { get => _ReadOperationMode; set => SetProperty(ref _ReadOperationMode, value); }
|
|
|
|
private int _WriteOperationMode;
|
|
public int WriteOperationMode { get => _WriteOperationMode; set => SetProperty(ref _WriteOperationMode, value); }
|
|
|
|
private string _ReadModelName;
|
|
public string ReadModelName { get => _ReadModelName; set => SetProperty(ref _ReadModelName, value); }
|
|
|
|
private string _ReadFirmwareRevision;
|
|
public string ReadFirmwareRevision { get => _ReadFirmwareRevision; set => SetProperty(ref _ReadFirmwareRevision, value); }
|
|
|
|
private string _ReadHardwareRevision;
|
|
public string ReadHardwareRevision { get => _ReadHardwareRevision; set => SetProperty(ref _ReadHardwareRevision, value); }
|
|
|
|
private string _ReadSerial;
|
|
public string ReadSerial { get => _ReadSerial; set => SetProperty(ref _ReadSerial, value); }
|
|
|
|
private eBaudRate _SelectedBaudRate = eBaudRate.bps_38400;
|
|
public eBaudRate SelectedBaudRate { get => _SelectedBaudRate; set => SetProperty(ref _SelectedBaudRate, value); }
|
|
|
|
private int _WriteBaudRate;
|
|
public int WriteBaudRate { get => _WriteBaudRate; set => SetProperty(ref _WriteBaudRate, value); }
|
|
|
|
private string _ReadGasName;
|
|
public string ReadGasName { get => _ReadGasName; set => SetProperty(ref _ReadGasName, value); }
|
|
|
|
private double _ReadFullScale;
|
|
public double ReadFullScale { get => _ReadFullScale; set => SetProperty(ref _ReadFullScale, value); }
|
|
|
|
private eFlowUnit _SelectedFlowUnit = eFlowUnit.CCM;
|
|
public eFlowUnit SelectedFlowUnit { get => _SelectedFlowUnit; set => SetProperty(ref _SelectedFlowUnit, value); }
|
|
|
|
private double _ReadIntegration;
|
|
public double ReadIntegration { get => _ReadIntegration; set => SetProperty(ref _ReadIntegration, value); }
|
|
|
|
private double _ResetIntegration;
|
|
public double ResetIntegration { get => _ResetIntegration; set => SetProperty(ref _ResetIntegration, value); }
|
|
|
|
private int _ReadIntegrationOn;
|
|
public int ReadIntegrationOn { get => _ReadIntegrationOn; set => SetProperty(ref _ReadIntegrationOn, value); }
|
|
|
|
private int _WriteIntegrationOn;
|
|
public int WriteIntegrationOn { get => _WriteIntegrationOn; set => SetProperty(ref _WriteIntegrationOn, value); }
|
|
|
|
private double _RampTime;
|
|
public double RampTime { get => _RampTime; set => SetProperty(ref _RampTime, value); }
|
|
|
|
private double _RampSetPoint;
|
|
public double RampSetPoint { get => _RampSetPoint; set => SetProperty(ref _RampSetPoint, value); }
|
|
|
|
private readonly MassFlowMeter _Device = null;
|
|
|
|
|
|
public UCMassFlowMeterDeviceViewModel(Device dev)
|
|
{
|
|
_Device = dev as MassFlowMeter;
|
|
|
|
CMD_VisibleChanged = new DelegateCommand(VisibleChanged);
|
|
|
|
CMD_WRITE_SET_POINT = new DelegateCommand(CmdWriteSetPoint);
|
|
CMD_READ_SET_POINT = new DelegateCommand(CmdReadSetPoint);
|
|
CMD_READ_FLOW = new DelegateCommand(CmdReadFlow);
|
|
CMD_READ_READING_ERROR = new DelegateCommand(CmdReadReadingError);
|
|
CMD_WRITE_READING_ERROR = new DelegateCommand(CmdWriteReadingError);
|
|
CMD_READ_MFC_STATUS = new DelegateCommand(CmdReadMFCStatus);
|
|
CMD_WRITE_DEVICE_ID = new DelegateCommand(CmdWriteDeviceID);
|
|
CMD_READ_DEVICE_ID = new DelegateCommand(CmdReadDeviceID);
|
|
CMD_READ_OPERATION_MODE = new DelegateCommand(CmdReadOperationMode);
|
|
CMD_WRITE_OPERATION_MODE = new DelegateCommand(CmdWriteOperationMode);
|
|
CMD_READ_MODEL_NAME = new DelegateCommand(CmdReadModelName);
|
|
CMD_READ_FIRMWARE_REVISION = new DelegateCommand(CmdReadFirmwareRevision);
|
|
CMD_READ_HARDWARE_REVISION = new DelegateCommand(CmdReadHardwareRevision);
|
|
CMD_READ_SERIAL = new DelegateCommand(CmdReadSerial);
|
|
CMD_READ_BAUD_RATE = new DelegateCommand(CmdReadBaudRate);
|
|
CMD_WRITE_BAUD_RATE = new DelegateCommand(CmdWriteBaudRate);
|
|
CMD_READ_GAS_NAME = new DelegateCommand(CmdReadGasName);
|
|
CMD_READ_FULL_SCALE = new DelegateCommand(CmdReadFullScale);
|
|
CMD_READ_FLOW_UNIT = new DelegateCommand(CmdReadFlowUnit);
|
|
CMD_READ_INTEGRATION = new DelegateCommand(CmdReadIntegration);
|
|
CMD_RESET_INTEGRATION = new DelegateCommand(CmdResetIntegration);
|
|
CMD_READ_INTEGRATION_ON = new DelegateCommand(CmdReadIntegrationOn);
|
|
CMD_WRITE_INTEGRATION_ON = new DelegateCommand(CmdWriteIntegrationOn);
|
|
CMD_WRITE_RAMP_SET_POINT = new DelegateCommand(CmdWriteRampSetPoint);
|
|
CMD_ZERO_OFFSET = new DelegateCommand(CmdZeroOffset);
|
|
|
|
MonitorTimer = new DispatcherTimer();
|
|
MonitorTimer.Tick += OnMonitoring;
|
|
MonitorTimer.Interval = TimeSpan.FromMilliseconds(1000);
|
|
|
|
// 파워미터가 두개라 디바이스 인덱스 같은걸로 받는 이벤트 등록 나눠야할듯. 아직 어떤 디바이스가 붙을지 몰라 보류.
|
|
//aurora.EventObservable.AsObservable(MassFlowMeterEvent.EVENT_ID_MEASURE_RESULT)
|
|
// .Select(msg => (ValueTuple<string, double>)msg.Param)
|
|
// .Where(msg => msg.Item1 == powerMeter.DeviceId)
|
|
// .Subscribe(power => OnPowerMeasured(power.Item2));
|
|
}
|
|
|
|
private void CmdZeroOffset(object obj)
|
|
{
|
|
if (_Device.ZeroOffset() == E1.OK) {
|
|
}
|
|
}
|
|
|
|
private void CmdWriteRampSetPoint(object obj)
|
|
{
|
|
if (_Device.WriteRampSetPoint(RampTime, RampSetPoint) == E1.OK) {
|
|
}
|
|
}
|
|
|
|
private void CmdWriteIntegrationOn(object obj)
|
|
{
|
|
if (_Device.WriteIntegrationOn((eIntegrationOn)WriteIntegrationOn) == E1.OK) {
|
|
}
|
|
}
|
|
|
|
//특주품 전용 커멘드
|
|
private void CmdReadIntegrationOn(object obj)
|
|
{
|
|
eIntegrationOn integrationOn;
|
|
if (_Device.ReadIntegrationOn(out integrationOn) == E1.OK) {
|
|
ReadIntegrationOn = (int)integrationOn;
|
|
}
|
|
}
|
|
//특주품 전용 커멘드
|
|
private void CmdResetIntegration(object obj)
|
|
{
|
|
double tempdouble;
|
|
if (_Device.ResetIntegration(out tempdouble) == E1.OK) {
|
|
ResetIntegration = tempdouble;
|
|
}
|
|
}
|
|
|
|
private void CmdReadIntegration(object obj)
|
|
{
|
|
double tempdouble;
|
|
if (_Device.ReadIntegration(out tempdouble) == E1.OK) {
|
|
ReadIntegration = tempdouble;
|
|
}
|
|
}
|
|
|
|
private void CmdReadFlowUnit(object obj)
|
|
{
|
|
eFlowUnit Flowunit;
|
|
if (_Device.ReadFlowUnit(out Flowunit) == E1.OK) {
|
|
SelectedFlowUnit = Flowunit;
|
|
}
|
|
}
|
|
|
|
private void CmdReadFullScale(object obj)
|
|
{
|
|
double tempdouble;
|
|
if (_Device.ReadFullScale(out tempdouble) == E1.OK) {
|
|
ReadFullScale = tempdouble;
|
|
}
|
|
}
|
|
|
|
private void CmdReadGasName(object obj)
|
|
{
|
|
string tempString;
|
|
if (_Device.ReadGasName(out tempString) == E1.OK) {
|
|
ReadGasName = tempString;
|
|
}
|
|
}
|
|
|
|
private void CmdWriteBaudRate(object obj)
|
|
{
|
|
if (_Device.WriteBaudRate((eBaudRate)WriteBaudRate) == E1.OK) {
|
|
}
|
|
}
|
|
|
|
private void CmdReadBaudRate(object obj)
|
|
{
|
|
eBaudRate tempBaudRate;
|
|
if (_Device.ReadBaudRate(out tempBaudRate) == E1.OK) {
|
|
SelectedBaudRate = tempBaudRate;
|
|
}
|
|
}
|
|
|
|
private void CmdReadSerial(object obj)
|
|
{
|
|
string tempString;
|
|
if (_Device.ReadSerial(out tempString) == E1.OK) {
|
|
ReadSerial = tempString;
|
|
}
|
|
}
|
|
|
|
private void CmdReadHardwareRevision(object obj)
|
|
{
|
|
string tempString;
|
|
if (_Device.ReadHardwareRevision(out tempString) == E1.OK) {
|
|
ReadHardwareRevision = tempString;
|
|
}
|
|
}
|
|
|
|
private void CmdReadFirmwareRevision(object obj)
|
|
{
|
|
string tempString;
|
|
if (_Device.ReadFirmwareRevision(out tempString) == E1.OK) {
|
|
ReadFirmwareRevision = tempString;
|
|
}
|
|
}
|
|
|
|
private void CmdReadModelName(object obj)
|
|
{
|
|
string tempString;
|
|
if (_Device.ReadModelName(out tempString) == E1.OK) {
|
|
ReadModelName = tempString;
|
|
}
|
|
}
|
|
|
|
private void CmdWriteOperationMode(object obj)
|
|
{
|
|
if (_Device.WriteOperationMode((eOperationMode)WriteOperationMode) == E1.OK) {
|
|
}
|
|
}
|
|
|
|
private void CmdReadOperationMode(object obj)
|
|
{
|
|
eOperationMode tempOperationMode;
|
|
if (_Device.ReadOperationMode(out tempOperationMode) == E1.OK) {
|
|
ReadOperationMode = (int)tempOperationMode;
|
|
}
|
|
}
|
|
|
|
private void CmdReadDeviceID(object obj)
|
|
{
|
|
int tempInt;
|
|
if (_Device.ReadDeviceId(out tempInt) == E1.OK) {
|
|
ReadDeviceID = tempInt;
|
|
}
|
|
}
|
|
|
|
private void CmdWriteDeviceID(object obj)
|
|
{
|
|
if (_Device.WriteDeviceId(WriteDeviceID) == E1.OK) {
|
|
}
|
|
}
|
|
|
|
private void CmdReadMFCStatus(object obj)
|
|
{
|
|
byte tempbyte;
|
|
if (_Device.ReadMFCStatus(out tempbyte) == E1.OK) {
|
|
|
|
// 상태표시를 위한 UI반영 필요
|
|
}
|
|
}
|
|
|
|
private void CmdWriteReadingError(object obj)
|
|
{
|
|
if (_Device.WriteReadingError(WriteReadingError) == E1.OK) {
|
|
}
|
|
}
|
|
|
|
private void CmdReadReadingError(object obj)
|
|
{
|
|
double tempdouble = double.NaN;
|
|
if (_Device.ReadReadingError(out tempdouble) == E1.OK) {
|
|
ReadReadingError = tempdouble;
|
|
}
|
|
ReadReadingError = tempdouble;
|
|
}
|
|
|
|
private void CmdReadFlow(object obj)
|
|
{
|
|
double tempdouble;
|
|
if (_Device.ReadFlow(out tempdouble) == E1.OK) {
|
|
ReadFlow = tempdouble;
|
|
}
|
|
}
|
|
|
|
private void CmdReadSetPoint(object obj)
|
|
{
|
|
double tempdouble;
|
|
if (_Device.ReadSetPoint(out tempdouble) == E1.OK) {
|
|
ReadSetPoint = tempdouble;
|
|
}
|
|
}
|
|
|
|
private void CmdWriteSetPoint(object obj)
|
|
{
|
|
if (_Device.WriteSetPoint( WriteSetPoint) == E1.OK) {
|
|
}
|
|
}
|
|
|
|
protected void VisibleChanged(object obj)
|
|
{
|
|
bool visible = (bool)obj;
|
|
if (visible)
|
|
{
|
|
MonitorTimer.Start();
|
|
}
|
|
else
|
|
{
|
|
MonitorTimer.Stop();
|
|
}
|
|
}
|
|
|
|
private void OnMonitoring(object sender, EventArgs e)
|
|
{
|
|
if (_Device.IsActivated)
|
|
{
|
|
var N2Meter = _Device as MassFlowMeter;
|
|
|
|
//CurrentPowerName = _Device.DeviceId;
|
|
//var deviceConfig = Application.Current.AuroraEnv().DeviceManager.GetDeviceConfig(_Device.DeviceId) as MassFlowMeterConfig;
|
|
//CurrentPortNumber = string.Format("{0}", (deviceConfig.ConnConfig as SerialConnConfig).PortNum);
|
|
|
|
//if (ContinuesMeasure)
|
|
// CurrentState = "측정중";
|
|
//else
|
|
// CurrentState = "대기중";
|
|
//if (ContinuesMeasure)
|
|
// //GetMeasurePower(null);
|
|
return;
|
|
}
|
|
//else
|
|
//CurrentState = "연결안됨";
|
|
}
|
|
|
|
private void GetMeasurePower(object obj)
|
|
{
|
|
if (!_Device.IsActivated)
|
|
{
|
|
//ContinuesMeasure = false;
|
|
return;
|
|
}
|
|
|
|
var powerMeter = _Device as MassFlowMeter;
|
|
double power = 0.0;
|
|
if (powerMeter.ReadSetPoint(out power) == E1.OK)
|
|
{
|
|
//CurrentPower = power;
|
|
//PowerMeterChart.AddPoint(power);
|
|
}
|
|
}
|
|
}
|
|
}
|