using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text;
|
using System.Threading;
|
using System.Threading.Tasks;
|
|
namespace SA_LTT.Module
|
{
|
public delegate void EnergyMeasuredEvent(double energy);
|
|
public class PowerMeter : ComPort
|
{
|
public enum MeasurementMode
|
{
|
QueryPresentMeasurementMode,
|
Passive,
|
Power,
|
Energy,
|
Exposure,
|
PowerWithPosition,
|
ReservedForFutureUse,
|
LuxForPD300_CIESensors,
|
DosageForPD300_RMSensors,
|
HoldModeForBC20Sensors,
|
ContinuousForBC20Sensors,
|
ReservedForFutureUse2,
|
PowerFromPulse,
|
}
|
|
private Equipment _equipment;
|
private Thread t_statusUpdate;
|
private bool _enable;
|
private string _ErrorDescription;
|
private bool _flag;
|
private double _energy;
|
private double _energyPerUnitArea;
|
private MeasurementMode _currentMeasurementMode;
|
private List<double> _measurementsEnergy;
|
private List<double> _measurementsEnergyPerUnitArea;
|
|
private DateTime _measurementChangedTime = DateTime.Now;
|
private double _measurementChangedWaitTime = 3;
|
public event EnergyMeasuredEvent EnergyMeasured;
|
|
|
public string ErrorDescription
|
{
|
get
|
{
|
return _ErrorDescription;
|
}
|
|
private set
|
{
|
_ErrorDescription = value;
|
}
|
}
|
|
public bool Flag
|
{
|
get
|
{
|
return _flag;
|
}
|
|
private set
|
{
|
_flag = value;
|
}
|
}
|
|
public MeasurementMode CurrentMeasurementMode
|
{
|
get
|
{
|
return _currentMeasurementMode;
|
}
|
|
private set
|
{
|
_currentMeasurementMode = value;
|
}
|
}
|
|
public double Energy
|
{
|
get
|
{
|
return _energy;
|
}
|
|
private set
|
{
|
_energy = value;
|
}
|
}
|
|
public double MeasurementAverageEnergy
|
{
|
get
|
{
|
double energy = 0;
|
|
if (MeasurementsEnergy.Count > 0)
|
{
|
energy = MeasurementsEnergy.Average();
|
energy = double.Parse($"{energy:F7}");
|
}
|
|
return energy;
|
}
|
}
|
|
public double MeasurementMaxEnergy
|
{
|
get
|
{
|
double energy = 0;
|
|
if (MeasurementsEnergy.Count > 0)
|
{
|
energy = MeasurementsEnergy.Max();
|
energy = double.Parse($"{energy:F7}");
|
}
|
|
return energy;
|
}
|
}
|
|
public double MeasurementMinEnergy
|
{
|
get
|
{
|
double energy = 0;
|
|
if (MeasurementsEnergy.Count > 0)
|
{
|
energy = MeasurementsEnergy.Min();
|
energy = double.Parse($"{energy:F7}");
|
}
|
|
return energy;
|
}
|
}
|
|
public List<double> MeasurementsEnergy
|
{
|
get
|
{
|
return _measurementsEnergy;
|
}
|
|
private set
|
{
|
_measurementsEnergy = value;
|
}
|
}
|
|
public double EnergyPerUnitArea
|
{
|
get
|
{
|
return _energyPerUnitArea;
|
}
|
|
set
|
{
|
_energyPerUnitArea = value;
|
}
|
}
|
|
public double MeasurementAverageEnergyPerUnitArea
|
{
|
get
|
{
|
double energy = 0;
|
|
if (MeasurementsEnergyPerUnitArea.Count > 0)
|
{
|
energy = MeasurementsEnergyPerUnitArea.Average();
|
energy = double.Parse($"{energy:F4}");
|
}
|
|
return energy;
|
}
|
}
|
|
public double MeasurementMaxEnergyPerUnitArea
|
{
|
get
|
{
|
double energy = 0;
|
|
if (MeasurementsEnergyPerUnitArea.Count > 0)
|
{
|
energy = MeasurementsEnergyPerUnitArea.Max();
|
energy = double.Parse($"{energy:F4}");
|
}
|
|
return energy;
|
}
|
}
|
|
public double MeasurementMinEnergyPerUnitArea
|
{
|
get
|
{
|
double energy = 0;
|
|
if (MeasurementsEnergyPerUnitArea.Count > 0)
|
{
|
energy = MeasurementsEnergyPerUnitArea.Min();
|
energy = double.Parse($"{energy:F4}");
|
}
|
|
return energy;
|
}
|
}
|
|
public List<double> MeasurementsEnergyPerUnitArea
|
{
|
get
|
{
|
return _measurementsEnergyPerUnitArea;
|
}
|
|
set
|
{
|
_measurementsEnergyPerUnitArea = value;
|
}
|
}
|
|
public bool Enable
|
{
|
get
|
{
|
return _enable;
|
}
|
|
private set
|
{
|
_enable = value;
|
}
|
}
|
|
public PowerMeter(Equipment equipment)
|
{
|
serialPort.PortName = "COM3";
|
serialPort.BaudRate = 115200;
|
serialPort.Parity = System.IO.Ports.Parity.None;
|
serialPort.DataBits = 8;
|
serialPort.StopBits = System.IO.Ports.StopBits.One;
|
serialPort.ReadTimeout = 1000;
|
Terminator = "\r\n";
|
|
_equipment = equipment;
|
|
MeasurementsEnergy = new List<double>();
|
MeasurementsEnergyPerUnitArea = new List<double>();
|
|
t_statusUpdate = new Thread(statusUpdate);
|
t_statusUpdate.Start();
|
}
|
|
public void statusUpdate()
|
{
|
while (_equipment.IsDisposed == false)
|
{
|
try
|
{
|
Thread.Sleep(100);
|
|
if (IsOpen)
|
{
|
if ((DateTime.Now - _measurementChangedTime).TotalSeconds < _measurementChangedWaitTime)
|
{
|
Enable = false;
|
continue;
|
}
|
else
|
{
|
Enable = true;
|
}
|
|
|
GetMeasurementMode();
|
|
if (CurrentMeasurementMode == MeasurementMode.Energy)
|
{
|
if(_equipment.chamber.IsPowerMeterPosition)
|
{
|
ReadEnergy();
|
}
|
}
|
}
|
else
|
{
|
if (_equipment.alarmManager.OccurredAlarms.Exists(x => x.Code == AlarmCode.AL_0059_POWERMETER_DISCONNECTED))
|
{
|
Close();
|
}
|
else
|
{
|
if (Open() == false)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0059_POWERMETER_DISCONNECTED);
|
}
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
}
|
}
|
|
public double ReadEnergy()
|
{
|
try
|
{
|
double energy = 0;
|
|
string flag = WriteRead("EF");
|
|
if (flag.Contains("1"))
|
{
|
Flag = true;
|
string energyData = WriteRead("SE");
|
|
if(double.TryParse(energyData, out energy))
|
{
|
Energy = energy;
|
EnergyPerUnitArea = Energy / (_equipment.settingParameterManager.SettingParameter.BeamHeight * _equipment.settingParameterManager.SettingParameter.BeamWidth);
|
|
Energy = double.Parse($"{Energy:F7}");
|
EnergyPerUnitArea = double.Parse($"{EnergyPerUnitArea * 100:F4}");
|
|
EquipmentLogManager.Instance.WriteEnergyMeterLog($"{energy}");
|
if (MeasurementsEnergy.Count >= int.MaxValue - 1000)
|
{
|
ResetMeasurementsEnergy();
|
}
|
|
MeasurementsEnergy.Add(Energy);
|
MeasurementsEnergyPerUnitArea.Add(EnergyPerUnitArea);
|
|
EnergyMeasured?.Invoke(EnergyPerUnitArea);
|
|
ErrorDescription = string.Empty;
|
}
|
else
|
{
|
Close();
|
Energy = energy;
|
ErrorDescription = energyData;
|
}
|
}
|
else
|
{
|
Flag = false;
|
Energy = 0;
|
EnergyPerUnitArea = 0;
|
}
|
|
return energy;
|
}
|
catch (Exception ex)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(ex.StackTrace + "\r\n" + ex.Message);
|
return 0;
|
}
|
}
|
|
public bool SetPowerMode()
|
{
|
if ((DateTime.Now - _measurementChangedTime).TotalSeconds < _measurementChangedWaitTime)
|
{
|
return false;
|
}
|
|
string result = WriteRead($"MM{MeasurementMode.Power:d}");
|
|
if (result.Contains("2"))
|
{
|
_currentMeasurementMode = MeasurementMode.Power;
|
Enable = false;
|
_measurementChangedTime = DateTime.Now;
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
|
public bool SetEnergyMode()
|
{
|
if ((DateTime.Now - _measurementChangedTime).TotalSeconds < _measurementChangedWaitTime)
|
{
|
return false;
|
}
|
|
string result = WriteRead($"MM{MeasurementMode.Energy:d}");
|
|
if(result.Contains("3"))
|
{
|
_currentMeasurementMode = MeasurementMode.Energy;
|
Enable = false;
|
_measurementChangedTime = DateTime.Now;
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
|
public MeasurementMode GetMeasurementMode()
|
{
|
MeasurementMode measurementMode = MeasurementMode.QueryPresentMeasurementMode;
|
|
string mode = WriteRead("MM");
|
|
int modeNumber;
|
|
if(int.TryParse(mode, out modeNumber))
|
{
|
measurementMode = (MeasurementMode)modeNumber;
|
|
if(measurementMode != MeasurementMode.Energy)
|
{
|
SetEnergyMode();
|
}
|
}
|
|
CurrentMeasurementMode = measurementMode;
|
|
return measurementMode;
|
}
|
|
public void ResetMeasurementsEnergy()
|
{
|
MeasurementsEnergy.Clear();
|
MeasurementsEnergyPerUnitArea.Clear();
|
}
|
|
public bool ResetEnergyMeter()
|
{
|
return SetPowerMode();
|
}
|
|
private new string WriteRead(string command)
|
{
|
string data = base.WriteRead("$" + command + "\r");
|
|
if(data == "")
|
{
|
return null;
|
}
|
else
|
{
|
return data.Replace("\r\n", "").Replace("*","");
|
}
|
}
|
}
|
}
|
