using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Globalization;
|
using System.Linq;
|
using System.Text;
|
using System.Threading;
|
using System.Threading.Tasks;
|
|
namespace SA_LTT.Module
|
{
|
public class Chiller : ComPort
|
{
|
public struct StatusFlag1
|
{
|
private bool[] _datas;
|
private bool _runFlag;
|
private bool _operationStopAlarmFlag;
|
private bool _operationContinuedAlarmFlag;
|
private bool _reserve3;
|
private bool _pressUnitFlag;
|
private bool _remoteStatusFlag;
|
private bool _reserve6;
|
private bool _reserve7;
|
private bool _reserve8;
|
private bool _completionOfPreparationFlag;
|
private bool _temperatureUnitFlag;
|
private bool _runTimerFlag;
|
private bool _stopTimerFlag;
|
private bool _resetAfterPowerFailureFlag;
|
private bool _antiFreezingFlag;
|
private bool _automaticFluidFillingFlag;
|
|
public bool[] Datas
|
{
|
get
|
{
|
if (_datas == null)
|
{
|
_datas = new bool[16];
|
}
|
|
return _datas;
|
}
|
|
private set
|
{
|
_datas = value;
|
}
|
}
|
|
public bool RunFlag
|
{
|
get
|
{
|
return _runFlag;
|
}
|
|
private set
|
{
|
_runFlag = value;
|
}
|
}
|
|
public bool OperationStopAlarmFlag
|
{
|
get
|
{
|
return _operationStopAlarmFlag;
|
}
|
|
private set
|
{
|
_operationStopAlarmFlag = value;
|
}
|
}
|
|
public bool OperationContinuedAlarmFlag
|
{
|
get
|
{
|
return _operationContinuedAlarmFlag;
|
}
|
|
private set
|
{
|
_operationContinuedAlarmFlag = value;
|
}
|
}
|
|
public bool Reserve3
|
{
|
get
|
{
|
return _reserve3;
|
}
|
|
private set
|
{
|
_reserve3 = value;
|
}
|
}
|
|
public bool PressUnitFlag
|
{
|
get
|
{
|
return _pressUnitFlag;
|
}
|
|
private set
|
{
|
_pressUnitFlag = value;
|
}
|
}
|
|
public bool RemoteStatusFlag
|
{
|
get
|
{
|
return _remoteStatusFlag;
|
}
|
|
private set
|
{
|
_remoteStatusFlag = value;
|
}
|
}
|
|
public bool Reserve6
|
{
|
get
|
{
|
return _reserve6;
|
}
|
|
private set
|
{
|
_reserve6 = value;
|
}
|
}
|
|
public bool Reserve7
|
{
|
get
|
{
|
return _reserve7;
|
}
|
|
private set
|
{
|
_reserve7 = value;
|
}
|
}
|
|
public bool Reserve8
|
{
|
get
|
{
|
return _reserve8;
|
}
|
|
private set
|
{
|
_reserve8 = value;
|
}
|
}
|
|
public bool CompletionOfPreparationFlag
|
{
|
get
|
{
|
return _completionOfPreparationFlag;
|
}
|
|
private set
|
{
|
_completionOfPreparationFlag = value;
|
}
|
}
|
|
public bool TemperatureUnitFlag
|
{
|
get
|
{
|
return _temperatureUnitFlag;
|
}
|
|
private set
|
{
|
_temperatureUnitFlag = value;
|
}
|
}
|
|
public bool RunTimerFlag
|
{
|
get
|
{
|
return _runTimerFlag;
|
}
|
|
private set
|
{
|
_runTimerFlag = value;
|
}
|
}
|
|
public bool StopTimerFlag
|
{
|
get
|
{
|
return _stopTimerFlag;
|
}
|
|
private set
|
{
|
_stopTimerFlag = value;
|
}
|
}
|
|
public bool ResetAfterPowerFailureFlag
|
{
|
get
|
{
|
return _resetAfterPowerFailureFlag;
|
}
|
|
private set
|
{
|
_resetAfterPowerFailureFlag = value;
|
}
|
}
|
|
public bool AntiFreezingFlag
|
{
|
get
|
{
|
return _antiFreezingFlag;
|
}
|
|
private set
|
{
|
_antiFreezingFlag = value;
|
}
|
}
|
|
public bool AutomaticFluidFillingFlag
|
{
|
get
|
{
|
return _automaticFluidFillingFlag;
|
}
|
|
private set
|
{
|
_automaticFluidFillingFlag = value;
|
}
|
}
|
|
public void SetData(byte[] bytes)
|
{
|
var bit = new BitArray(bytes);
|
|
if (bit.Length < 16) return;
|
|
for (int i = 0; i < 16; i++)
|
{
|
Datas[i] = bit[i];
|
}
|
|
RunFlag = bit[0];
|
OperationStopAlarmFlag = bit[1];
|
OperationContinuedAlarmFlag = bit[2];
|
Reserve3 = bit[3];
|
PressUnitFlag = bit[4];
|
RemoteStatusFlag = bit[5];
|
Reserve6 = bit[6];
|
Reserve7 = bit[7];
|
Reserve8 = bit[8];
|
CompletionOfPreparationFlag = bit[9];
|
TemperatureUnitFlag = bit[10];
|
RunTimerFlag = bit[11];
|
StopTimerFlag = bit[12];
|
ResetAfterPowerFailureFlag = bit[13];
|
AntiFreezingFlag = bit[14];
|
AutomaticFluidFillingFlag = bit[15];
|
}
|
}
|
|
public struct AlarmFlag1
|
{
|
private bool[] _datas;
|
private bool _lowLevelInTank;
|
private bool _highCirculatingFluidDischargeTemp;
|
private bool _circulatingFluidDischargeTempRise;
|
private bool _circulatingFluidDischargeTempDrop;
|
private bool _highCirculatingFluidReturnTemp;
|
private bool _highCirculatingFluidDischargePressure;
|
private bool _abnormalPumpOperation;
|
private bool _circulatingFluidDischargePressureRise;
|
private bool _circulatingFluidDischargePressureDrop;
|
private bool _highCompressorIntakeTemp;
|
private bool _lowCompressorIntakeTemp;
|
private bool _lowSuperHeatTemperature;
|
private bool _highCompressorDischargePressure;
|
private bool _reserve13;
|
private bool _refrigerantCircuitHighPressureDrop;
|
private bool _refrigerantCircuitLowPressureRise;
|
|
public bool[] Datas
|
{
|
get
|
{
|
if (_datas == null)
|
{
|
_datas = new bool[16];
|
}
|
|
return _datas;
|
}
|
|
private set
|
{
|
_datas = value;
|
}
|
}
|
|
public bool LowLevelInTank
|
{
|
get
|
{
|
return _lowLevelInTank;
|
}
|
|
private set
|
{
|
_lowLevelInTank = value;
|
}
|
}
|
|
public bool HighCirculatingFluidDischargeTemp
|
{
|
get
|
{
|
return _highCirculatingFluidDischargeTemp;
|
}
|
|
private set
|
{
|
_highCirculatingFluidDischargeTemp = value;
|
}
|
}
|
|
public bool CirculatingFluidDischargeTempRise
|
{
|
get
|
{
|
return _circulatingFluidDischargeTempRise;
|
}
|
|
private set
|
{
|
_circulatingFluidDischargeTempRise = value;
|
}
|
}
|
|
public bool CirculatingFluidDischargeTempDrop
|
{
|
get
|
{
|
return _circulatingFluidDischargeTempDrop;
|
}
|
|
private set
|
{
|
_circulatingFluidDischargeTempDrop = value;
|
}
|
}
|
|
public bool HighCirculatingFluidReturnTemp
|
{
|
get
|
{
|
return _highCirculatingFluidReturnTemp;
|
}
|
|
private set
|
{
|
_highCirculatingFluidReturnTemp = value;
|
}
|
}
|
|
public bool HighCirculatingFluidDischargePressure
|
{
|
get
|
{
|
return _highCirculatingFluidDischargePressure;
|
}
|
|
private set
|
{
|
_highCirculatingFluidDischargePressure = value;
|
}
|
}
|
|
public bool AbnormalPumpOperation
|
{
|
get
|
{
|
return _abnormalPumpOperation;
|
}
|
|
private set
|
{
|
_abnormalPumpOperation = value;
|
}
|
}
|
|
public bool CirculatingFluidDischargePressureRise
|
{
|
get
|
{
|
return _circulatingFluidDischargePressureRise;
|
}
|
|
private set
|
{
|
_circulatingFluidDischargePressureRise = value;
|
}
|
}
|
|
public bool CirculatingFluidDischargePressureDrop
|
{
|
get
|
{
|
return _circulatingFluidDischargePressureDrop;
|
}
|
|
private set
|
{
|
_circulatingFluidDischargePressureDrop = value;
|
}
|
}
|
|
public bool HighCompressorIntakeTemp
|
{
|
get
|
{
|
return _highCompressorIntakeTemp;
|
}
|
|
private set
|
{
|
_highCompressorIntakeTemp = value;
|
}
|
}
|
|
public bool LowCompressorIntakeTemp
|
{
|
get
|
{
|
return _lowCompressorIntakeTemp;
|
}
|
|
private set
|
{
|
_lowCompressorIntakeTemp = value;
|
}
|
}
|
|
public bool LowSuperHeatTemperature
|
{
|
get
|
{
|
return _lowSuperHeatTemperature;
|
}
|
|
private set
|
{
|
_lowSuperHeatTemperature = value;
|
}
|
}
|
|
public bool HighCompressorDischargePressure
|
{
|
get
|
{
|
return _highCompressorDischargePressure;
|
}
|
|
private set
|
{
|
_highCompressorDischargePressure = value;
|
}
|
}
|
|
public bool Reserve13
|
{
|
get
|
{
|
return _reserve13;
|
}
|
|
private set
|
{
|
_reserve13 = value;
|
}
|
}
|
|
public bool RefrigerantCircuitHighPressureDrop
|
{
|
get
|
{
|
return _refrigerantCircuitHighPressureDrop;
|
}
|
|
private set
|
{
|
_refrigerantCircuitHighPressureDrop = value;
|
}
|
}
|
|
public bool RefrigerantCircuitLowPressureRise
|
{
|
get
|
{
|
return _refrigerantCircuitLowPressureRise;
|
}
|
|
private set
|
{
|
_refrigerantCircuitLowPressureRise = value;
|
}
|
}
|
|
public void SetData(byte[] bytes)
|
{
|
if (_datas == null)
|
{
|
_datas = new bool[16];
|
}
|
|
var bit = new BitArray(bytes);
|
|
if (bit.Length < 16) return;
|
|
for (int i = 0; i < 16; i++)
|
{
|
_datas[i] = bit[i];
|
}
|
|
LowLevelInTank = bit[0];
|
HighCirculatingFluidDischargeTemp = bit[1];
|
CirculatingFluidDischargeTempRise = bit[2];
|
CirculatingFluidDischargeTempDrop = bit[3];
|
HighCirculatingFluidReturnTemp = bit[4];
|
HighCirculatingFluidDischargePressure = bit[5];
|
AbnormalPumpOperation = bit[6];
|
CirculatingFluidDischargePressureRise = bit[7];
|
CirculatingFluidDischargePressureDrop = bit[8];
|
HighCompressorIntakeTemp = bit[9];
|
LowCompressorIntakeTemp = bit[10];
|
LowSuperHeatTemperature = bit[11];
|
HighCompressorDischargePressure = bit[12];
|
Reserve13 = bit[13];
|
RefrigerantCircuitHighPressureDrop = bit[14];
|
RefrigerantCircuitLowPressureRise = bit[15];
|
}
|
}
|
|
public struct AlarmFlag2
|
{
|
private bool[] _datas;
|
private bool _refrigerantCircuitLowPressureDrop;
|
private bool _compressorOverload;
|
private bool _communicationError;
|
private bool _memoryError;
|
private bool _dcLineFuseCut;
|
private bool _circulatingFluidDischargeTempSensorFailure;
|
private bool _circulatingFluidReturnTempSensorFailure;
|
private bool _compressorIntankTempSensorFailure;
|
private bool _circulatingFluidDischargePressureSensorFailure;
|
private bool _compressorDischargePressureSensorFailure;
|
private bool _compressorIntankPressureSensorFailure;
|
private bool _maintenanceOfPump;
|
private bool _maintenanceOfFanMotor;
|
private bool _maintenanceOfCompressor;
|
private bool _contactInput1SignalDetectionAlarm;
|
private bool _contactInput2SignalDetectionAlarm;
|
|
public bool[] Datas
|
{
|
get
|
{
|
if (_datas == null)
|
{
|
_datas = new bool[16];
|
}
|
|
return _datas;
|
}
|
|
private set
|
{
|
_datas = value;
|
}
|
}
|
|
public bool RefrigerantCircuitLowPressureDrop
|
{
|
get
|
{
|
return _refrigerantCircuitLowPressureDrop;
|
}
|
|
private set
|
{
|
_refrigerantCircuitLowPressureDrop = value;
|
}
|
}
|
|
public bool CompressorOverload
|
{
|
get
|
{
|
return _compressorOverload;
|
}
|
|
private set
|
{
|
_compressorOverload = value;
|
}
|
}
|
|
public bool CommunicationError
|
{
|
get
|
{
|
return _communicationError;
|
}
|
|
private set
|
{
|
_communicationError = value;
|
}
|
}
|
|
public bool MemoryError
|
{
|
get
|
{
|
return _memoryError;
|
}
|
|
private set
|
{
|
_memoryError = value;
|
}
|
}
|
|
public bool DcLineFuseCut
|
{
|
get
|
{
|
return _dcLineFuseCut;
|
}
|
|
private set
|
{
|
_dcLineFuseCut = value;
|
}
|
}
|
|
public bool CirculatingFluidDischargeTempSensorFailure
|
{
|
get
|
{
|
return _circulatingFluidDischargeTempSensorFailure;
|
}
|
|
private set
|
{
|
_circulatingFluidDischargeTempSensorFailure = value;
|
}
|
}
|
|
public bool CirculatingFluidReturnTempSensorFailure
|
{
|
get
|
{
|
return _circulatingFluidReturnTempSensorFailure;
|
}
|
|
private set
|
{
|
_circulatingFluidReturnTempSensorFailure = value;
|
}
|
}
|
|
public bool CompressorIntankTempSensorFailure
|
{
|
get
|
{
|
return _compressorIntankTempSensorFailure;
|
}
|
|
private set
|
{
|
_compressorIntankTempSensorFailure = value;
|
}
|
}
|
|
public bool CirculatingFluidDischargePressureSensorFailure
|
{
|
get
|
{
|
return _circulatingFluidDischargePressureSensorFailure;
|
}
|
|
private set
|
{
|
_circulatingFluidDischargePressureSensorFailure = value;
|
}
|
}
|
|
public bool CompressorDischargePressureSensorFailure
|
{
|
get
|
{
|
return _compressorDischargePressureSensorFailure;
|
}
|
|
private set
|
{
|
_compressorDischargePressureSensorFailure = value;
|
}
|
}
|
|
public bool CompressorIntankPressureSensorFailure
|
{
|
get
|
{
|
return _compressorIntankPressureSensorFailure;
|
}
|
|
private set
|
{
|
_compressorIntankPressureSensorFailure = value;
|
}
|
}
|
|
public bool MaintenanceOfPump
|
{
|
get
|
{
|
return _maintenanceOfPump;
|
}
|
|
private set
|
{
|
_maintenanceOfPump = value;
|
}
|
}
|
|
public bool MaintenanceOfFanMotor
|
{
|
get
|
{
|
return _maintenanceOfFanMotor;
|
}
|
|
private set
|
{
|
_maintenanceOfFanMotor = value;
|
}
|
}
|
|
public bool MaintenanceOfCompressor
|
{
|
get
|
{
|
return _maintenanceOfCompressor;
|
}
|
|
private set
|
{
|
_maintenanceOfCompressor = value;
|
}
|
}
|
|
public bool ContactInput1SignalDetectionAlarm
|
{
|
get
|
{
|
return _contactInput1SignalDetectionAlarm;
|
}
|
|
private set
|
{
|
_contactInput1SignalDetectionAlarm = value;
|
}
|
}
|
|
public bool ContactInput2SignalDetectionAlarm
|
{
|
get
|
{
|
return _contactInput2SignalDetectionAlarm;
|
}
|
|
private set
|
{
|
_contactInput2SignalDetectionAlarm = value;
|
}
|
}
|
|
public void SetData(byte[] bytes)
|
{
|
var bit = new BitArray(bytes);
|
|
if (bit.Length < 16) return;
|
|
for (int i = 0; i < 16; i++)
|
{
|
Datas[i] = bit[i];
|
}
|
|
RefrigerantCircuitLowPressureDrop = bit[0];
|
CompressorOverload = bit[1];
|
CommunicationError = bit[2];
|
MemoryError = bit[3];
|
DcLineFuseCut = bit[4];
|
CirculatingFluidDischargeTempSensorFailure = bit[5];
|
CirculatingFluidReturnTempSensorFailure = bit[6];
|
CompressorIntankTempSensorFailure = bit[7];
|
CirculatingFluidDischargePressureSensorFailure = bit[8];
|
CompressorDischargePressureSensorFailure = bit[9];
|
CompressorIntankPressureSensorFailure = bit[10];
|
MaintenanceOfPump = bit[11];
|
MaintenanceOfFanMotor = bit[12];
|
MaintenanceOfCompressor = bit[13];
|
ContactInput1SignalDetectionAlarm = bit[14];
|
ContactInput2SignalDetectionAlarm = bit[15];
|
}
|
}
|
|
public struct AlarmFlag3
|
{
|
private bool[] _datas;
|
private bool _waterLeakage;
|
private bool _electricResistivityConductivityLevelRise;
|
private bool _electricResistivityConductivityLevelDrop;
|
private bool _electricResistivityConductivitySensorError;
|
private bool _reserve4;
|
private bool _reserve5;
|
private bool _reserve6;
|
private bool _reserve7;
|
private bool _reserve8;
|
private bool _reserve9;
|
private bool _reserve10;
|
private bool _reserve11;
|
private bool _reserve12;
|
private bool _reserve13;
|
private bool _reserve14;
|
private bool _reserve15;
|
|
public bool[] Datas
|
{
|
get
|
{
|
if (_datas == null)
|
{
|
_datas = new bool[16];
|
}
|
|
return _datas;
|
}
|
|
private set
|
{
|
_datas = value;
|
}
|
}
|
|
public bool WaterLeakage
|
{
|
get
|
{
|
return _waterLeakage;
|
}
|
|
private set
|
{
|
_waterLeakage = value;
|
}
|
}
|
|
public bool ElectricResistivityConductivityLevelRise
|
{
|
get
|
{
|
return _electricResistivityConductivityLevelRise;
|
}
|
|
private set
|
{
|
_electricResistivityConductivityLevelRise = value;
|
}
|
}
|
|
public bool ElectricResistivityConductivityLevelDrop
|
{
|
get
|
{
|
return _electricResistivityConductivityLevelDrop;
|
}
|
|
private set
|
{
|
_electricResistivityConductivityLevelDrop = value;
|
}
|
}
|
|
public bool ElectricResistivityConductivitySensorError
|
{
|
get
|
{
|
return _electricResistivityConductivitySensorError;
|
}
|
|
private set
|
{
|
_electricResistivityConductivitySensorError = value;
|
}
|
}
|
|
public bool Reserve4
|
{
|
get
|
{
|
return _reserve4;
|
}
|
|
private set
|
{
|
_reserve4 = value;
|
}
|
}
|
|
public bool Reserve5
|
{
|
get
|
{
|
return _reserve5;
|
}
|
|
private set
|
{
|
_reserve5 = value;
|
}
|
}
|
|
public bool Reserve6
|
{
|
get
|
{
|
return _reserve6;
|
}
|
|
private set
|
{
|
_reserve6 = value;
|
}
|
}
|
|
public bool Reserve7
|
{
|
get
|
{
|
return _reserve7;
|
}
|
|
private set
|
{
|
_reserve7 = value;
|
}
|
}
|
|
public bool Reserve8
|
{
|
get
|
{
|
return _reserve8;
|
}
|
|
private set
|
{
|
_reserve8 = value;
|
}
|
}
|
|
public bool Reserve9
|
{
|
get
|
{
|
return _reserve9;
|
}
|
|
private set
|
{
|
_reserve9 = value;
|
}
|
}
|
|
public bool Reserve10
|
{
|
get
|
{
|
return _reserve10;
|
}
|
|
private set
|
{
|
_reserve10 = value;
|
}
|
}
|
|
public bool Reserve11
|
{
|
get
|
{
|
return _reserve11;
|
}
|
|
private set
|
{
|
_reserve11 = value;
|
}
|
}
|
|
public bool Reserve12
|
{
|
get
|
{
|
return _reserve12;
|
}
|
|
private set
|
{
|
_reserve12 = value;
|
}
|
}
|
|
public bool Reserve13
|
{
|
get
|
{
|
return _reserve13;
|
}
|
|
private set
|
{
|
_reserve13 = value;
|
}
|
}
|
|
public bool Reserve14
|
{
|
get
|
{
|
return _reserve14;
|
}
|
|
private set
|
{
|
_reserve14 = value;
|
}
|
}
|
|
public bool Reserve15
|
{
|
get
|
{
|
return _reserve15;
|
}
|
|
private set
|
{
|
_reserve15 = value;
|
}
|
}
|
|
public void SetData(byte[] bytes)
|
{
|
var bit = new BitArray(bytes);
|
|
if (bit.Length < 16) return;
|
|
for (int i = 0; i < 16; i++)
|
{
|
Datas[i] = bit[i];
|
}
|
|
WaterLeakage = bit[0];
|
ElectricResistivityConductivityLevelRise = bit[1];
|
ElectricResistivityConductivityLevelDrop = bit[2];
|
ElectricResistivityConductivitySensorError = bit[3];
|
Reserve4 = bit[4];
|
Reserve5 = bit[5];
|
Reserve6 = bit[6];
|
Reserve7 = bit[7];
|
Reserve8 = bit[8];
|
Reserve9 = bit[9];
|
Reserve10 = bit[10];
|
Reserve11 = bit[11];
|
Reserve12 = bit[12];
|
Reserve13 = bit[13];
|
Reserve14 = bit[14];
|
Reserve15 = bit[15];
|
}
|
}
|
|
public struct StatusFlag2
|
{
|
private bool[] _datas;
|
|
private bool _electricResistivityConductivitySettingFlag1;
|
private bool _electricResistivityConductivitySettingFlag2;
|
private bool _reserve2;
|
private bool _reserve3;
|
private bool _reserve4;
|
private bool _reserve5;
|
private bool _reserve6;
|
private bool _reserve7;
|
private bool _reserve8;
|
private bool _reserve9;
|
private bool _reserve10;
|
private bool _reserve11;
|
private bool _reserve12;
|
private bool _reserve13;
|
private bool _reserve14;
|
private bool _reserve15;
|
|
public bool[] Datas
|
{
|
get
|
{
|
if (_datas == null)
|
{
|
_datas = new bool[16];
|
}
|
|
return _datas;
|
}
|
|
private set
|
{
|
_datas = value;
|
}
|
}
|
|
public bool ElectricResistivityConductivitySettingFlag1
|
{
|
get
|
{
|
return _electricResistivityConductivitySettingFlag1;
|
}
|
|
private set
|
{
|
_electricResistivityConductivitySettingFlag1 = value;
|
}
|
}
|
|
public bool ElectricResistivityConductivitySettingFlag2
|
{
|
get
|
{
|
return _electricResistivityConductivitySettingFlag2;
|
}
|
|
private set
|
{
|
_electricResistivityConductivitySettingFlag2 = value;
|
}
|
}
|
|
public bool Reserve2
|
{
|
get
|
{
|
return _reserve2;
|
}
|
|
private set
|
{
|
_reserve2 = value;
|
}
|
}
|
|
public bool Reserve3
|
{
|
get
|
{
|
return _reserve3;
|
}
|
|
private set
|
{
|
_reserve3 = value;
|
}
|
}
|
|
public bool Reserve4
|
{
|
get
|
{
|
return _reserve4;
|
}
|
|
private set
|
{
|
_reserve4 = value;
|
}
|
}
|
|
public bool Reserve5
|
{
|
get
|
{
|
return _reserve5;
|
}
|
|
private set
|
{
|
_reserve5 = value;
|
}
|
}
|
|
public bool Reserve6
|
{
|
get
|
{
|
return _reserve6;
|
}
|
|
private set
|
{
|
_reserve6 = value;
|
}
|
}
|
|
public bool Reserve7
|
{
|
get
|
{
|
return _reserve7;
|
}
|
|
private set
|
{
|
_reserve7 = value;
|
}
|
}
|
|
public bool Reserve8
|
{
|
get
|
{
|
return _reserve8;
|
}
|
|
private set
|
{
|
_reserve8 = value;
|
}
|
}
|
|
public bool Reserve9
|
{
|
get
|
{
|
return _reserve9;
|
}
|
|
private set
|
{
|
_reserve9 = value;
|
}
|
}
|
|
public bool Reserve10
|
{
|
get
|
{
|
return _reserve10;
|
}
|
|
private set
|
{
|
_reserve10 = value;
|
}
|
}
|
|
public bool Reserve11
|
{
|
get
|
{
|
return _reserve11;
|
}
|
|
private set
|
{
|
_reserve11 = value;
|
}
|
}
|
|
public bool Reserve12
|
{
|
get
|
{
|
return _reserve12;
|
}
|
|
private set
|
{
|
_reserve12 = value;
|
}
|
}
|
|
public bool Reserve13
|
{
|
get
|
{
|
return _reserve13;
|
}
|
|
private set
|
{
|
_reserve13 = value;
|
}
|
}
|
|
public bool Reserve14
|
{
|
get
|
{
|
return _reserve14;
|
}
|
|
private set
|
{
|
_reserve14 = value;
|
}
|
}
|
|
public bool Reserve15
|
{
|
get
|
{
|
return _reserve15;
|
}
|
|
private set
|
{
|
_reserve15 = value;
|
}
|
}
|
|
public void SetData(byte[] bytes)
|
{
|
var bit = new BitArray(bytes);
|
|
if (bit.Length < 16) return;
|
|
for (int i = 0; i < 16; i++)
|
{
|
Datas[i] = bit[i];
|
}
|
|
ElectricResistivityConductivitySettingFlag1 = bit[0];
|
ElectricResistivityConductivitySettingFlag2 = bit[1];
|
Reserve2 = bit[2];
|
Reserve3 = bit[3];
|
Reserve4 = bit[4];
|
Reserve5 = bit[5];
|
Reserve6 = bit[6];
|
Reserve7 = bit[7];
|
Reserve8 = bit[8];
|
Reserve9 = bit[9];
|
Reserve10 = bit[10];
|
Reserve11 = bit[11];
|
Reserve12 = bit[12];
|
Reserve13 = bit[13];
|
Reserve14 = bit[14];
|
Reserve15 = bit[15];
|
}
|
}
|
|
Equipment _equipment;
|
|
public StatusFlag1 statusFlag1 = new StatusFlag1();
|
public AlarmFlag1 alarmFlag1 = new AlarmFlag1();
|
public AlarmFlag2 alarmFlag2 = new AlarmFlag2();
|
public AlarmFlag3 alarmFlag3 = new AlarmFlag3();
|
public StatusFlag2 statusFlag2 = new StatusFlag2();
|
|
private float _circulatingFluidDischargeTemperature;
|
private float _circulatingFluidDischargePressure;
|
private float _electricResistivity;
|
private float _circulatingFluidSetTemperature;
|
|
private Thread t_statusUpdate;
|
|
public float CirculatingFluidDischargeTemperature
|
{
|
get
|
{
|
return _circulatingFluidDischargeTemperature;
|
}
|
|
private set
|
{
|
_circulatingFluidDischargeTemperature = value;
|
}
|
}
|
|
public float CirculatingFluidDischargePressure
|
{
|
get
|
{
|
return _circulatingFluidDischargePressure;
|
}
|
|
private set
|
{
|
_circulatingFluidDischargePressure = value;
|
}
|
}
|
|
public float ElectricResistivity
|
{
|
get
|
{
|
return _electricResistivity;
|
}
|
|
private set
|
{
|
_electricResistivity = value;
|
}
|
}
|
|
public float CirculatingFluidSetTemperature
|
{
|
get
|
{
|
return _circulatingFluidSetTemperature;
|
}
|
|
private set
|
{
|
_circulatingFluidSetTemperature = value;
|
}
|
}
|
|
public Chiller(Equipment equipment)
|
{
|
_equipment = equipment;
|
|
serialPort.PortName = "COM10";
|
serialPort.BaudRate = 19200;
|
serialPort.Parity = System.IO.Ports.Parity.Even;
|
serialPort.DataBits = 7;
|
serialPort.StopBits = System.IO.Ports.StopBits.One;
|
serialPort.ReadTimeout = 500;
|
ReceiveWaitSeconds = 0.1;
|
|
Terminator = "\r\n";
|
|
t_statusUpdate = new Thread(statusUpdate);
|
t_statusUpdate.Start();
|
}
|
|
public void statusUpdate()
|
{
|
while (_equipment.IsDisposed == false)
|
{
|
try
|
{
|
Thread.Sleep(500);
|
|
if (IsOpen)
|
{
|
// Todo. Command 설정.
|
GetStatus();
|
AlarmCheck();
|
}
|
else
|
{
|
if (_equipment.alarmManager.OccurredAlarms.Exists(x => x.Code == AlarmCode.AL_0061_CHILLER_DISCONNECTED))
|
{
|
|
}
|
else
|
{
|
if (Open() == false)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0061_CHILLER_DISCONNECTED);
|
}
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
|
}
|
}
|
}
|
|
public void Run()
|
{
|
string command = ":0106000C0001EC\r\n";
|
|
string data = WriteRead(command);
|
}
|
|
public void Stop()
|
{
|
string command = ":0106000C0000EB\r\n";
|
|
string data = WriteRead(command);
|
}
|
|
public void GetStatus()
|
{
|
// Todo. Read Registry가 이상함;; 재확인 필요.
|
// 0000 부터 000C 까지 읽음.
|
string command = ":01030000000DEF\r\n";
|
|
string data = WriteRead(command);
|
|
if(data == string.Empty)
|
{
|
return;
|
}
|
data = data.Replace(":", "");
|
//data = "01031A00B4000000180000000100000000000000000000000000B4000160";
|
string code = data.Substring(0, 2);
|
string function = data.Substring(2, 2);
|
|
//수정
|
string byteCount = data.Substring(4, 2);
|
|
string dischargeTemperature = data.Substring(6, 4);
|
string reserved1 = data.Substring(10, 4);
|
string dischargePressure = data.Substring(14, 4);
|
string electricResistivityFluid = data.Substring(18, 4);
|
string statusFlag1 = data.Substring(22, 4);
|
string alarmFlag1 = data.Substring(26, 4);
|
string alarmFlag2 = data.Substring(30, 4);
|
string alarmFlag3 = data.Substring(34, 4);
|
string reserved2 = data.Substring(38, 4);
|
string statusFlag2 = data.Substring(42, 4);
|
string reserved3 = data.Substring(46, 4);
|
string circulatingTemperature = data.Substring(50, 4);
|
string commandToRun = data.Substring(54, 4);
|
|
int fluidDischargeTemperature = int.Parse(dischargeTemperature, NumberStyles.HexNumber);
|
int fluidDischargePressure = int.Parse(dischargePressure, NumberStyles.HexNumber);
|
int electricResistivity = int.Parse(electricResistivityFluid, NumberStyles.HexNumber);
|
int fluidSetTemperature = int.Parse(circulatingTemperature, NumberStyles.HexNumber);
|
int dd = int.Parse(reserved1, NumberStyles.HexNumber);
|
|
CirculatingFluidDischargeTemperature = fluidDischargeTemperature * 0.1f;
|
CirculatingFluidDischargePressure = fluidDischargePressure * 0.01f;
|
ElectricResistivity = electricResistivity * 0.1f;
|
CirculatingFluidSetTemperature = fluidSetTemperature * 0.1f;
|
|
SetStatusFlag1(statusFlag1);
|
SetStatusFlag2(statusFlag2);
|
|
SetAlarmFlag1(alarmFlag1);
|
SetAlarmFlag2(alarmFlag2);
|
SetAlarmFlag3(alarmFlag3);
|
}
|
|
private void SetStatusFlag1(string statusFlag1)
|
{
|
int integerStatusFlag = int.Parse(statusFlag1, NumberStyles.HexNumber);
|
byte[] status = BitConverter.GetBytes(integerStatusFlag);
|
|
this.statusFlag1.SetData(status);
|
}
|
|
private void SetStatusFlag2(string statusFlag2)
|
{
|
int integerStatusFlag = int.Parse(statusFlag2, NumberStyles.HexNumber);
|
byte[] status = BitConverter.GetBytes(integerStatusFlag);
|
|
this.statusFlag2.SetData(status);
|
}
|
|
private void SetAlarmFlag1(string alarmFlag1)
|
{
|
int integerAlarmFlag = int.Parse(alarmFlag1, NumberStyles.HexNumber);
|
byte[] alarms = BitConverter.GetBytes(integerAlarmFlag);
|
|
this.alarmFlag1.SetData(alarms);
|
}
|
|
private void SetAlarmFlag2(string alarmFlag2)
|
{
|
int integerAlarmFlag = int.Parse(alarmFlag2, NumberStyles.HexNumber);
|
byte[] alarms = BitConverter.GetBytes(integerAlarmFlag);
|
|
this.alarmFlag2.SetData(alarms);
|
}
|
|
private void SetAlarmFlag3(string alarmFlag3)
|
{
|
int integerAlarmFlag = int.Parse(alarmFlag3, NumberStyles.HexNumber);
|
byte[] alarms = BitConverter.GetBytes(integerAlarmFlag);
|
|
this.alarmFlag3.SetData(alarms);
|
}
|
|
public void AlarmCheck()
|
{
|
// Alarm 1
|
if(alarmFlag1.LowLevelInTank)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0400_CHILLER_LOW_LEVEL_IN_TANK);
|
}
|
if (alarmFlag1.HighCirculatingFluidDischargeTemp)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0401_CHILLER_HIGH_CIRCULATING_FLUID_DISCHARGE_TEMP);
|
}
|
if (alarmFlag1.CirculatingFluidDischargeTempRise)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0402_CHILLER_CIRCULATING_FLUID_DISCHARGE_TEMP_RISE);
|
}
|
if (alarmFlag1.CirculatingFluidDischargeTempDrop)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0403_CHILLER_CIRCULATING_FLUID_DISCHARGE_TEMP_DROP);
|
}
|
if (alarmFlag1.HighCirculatingFluidReturnTemp)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0404_CHILLER_HIGH_CIRCULATING_FLUID_RETURN_TEMP);
|
}
|
if (alarmFlag1.HighCirculatingFluidDischargePressure)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0405_CHILLER_HIGH_CIRCULATING_FLUID_DISCHARGE_PRESSURE);
|
}
|
if (alarmFlag1.AbnormalPumpOperation)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0406_CHILLER_ABNORMAL_PUMP_OPERATION);
|
}
|
if (alarmFlag1.CirculatingFluidDischargePressureRise)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0407_CHILLER_CIRCULATING_FLUID_DISCHARGE_PRESSURE_RISE);
|
}
|
if (alarmFlag1.CirculatingFluidDischargePressureDrop)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0408_CHILLER_CIRCULATING_FLUID_DISCHARGE_PRESSURE_DROP);
|
}
|
if (alarmFlag1.HighCompressorIntakeTemp)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0409_CHILLER_HIGH_COMPRESSOR_INTANK_TEMP);
|
}
|
if (alarmFlag1.LowCompressorIntakeTemp)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0410_CHILLER_LOW_COMPRESSOR_INTANK_TEMP);
|
}
|
if (alarmFlag1.LowSuperHeatTemperature)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0411_CHILLER_LOW_SUPER_HEAT_TEMPERATURE);
|
}
|
if (alarmFlag1.HighCompressorDischargePressure)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0412_CHILLER_HIGH_COMPRESSOR_DISCHARGE_PRESSURE);
|
}
|
if (alarmFlag1.RefrigerantCircuitHighPressureDrop)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0413_CHILLER_REFRIGERANT_CIRCUIT_HIGH_PRESSURE_DROP);
|
}
|
if (alarmFlag1.RefrigerantCircuitLowPressureRise)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0414_CHILLER_REFRIGERANT_CIRCUIT_LOW_PRESSURE_RISE);
|
}
|
|
// Alarm 2
|
if(alarmFlag2.RefrigerantCircuitLowPressureDrop)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0415_CHILLER_REFRIGERANT_CIRCUIT_LOW_PRESSURE_DROP);
|
}
|
if (alarmFlag2.CompressorOverload)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0416_CHILLER_COMPRESSOR_OVER_LOAD);
|
}
|
if (alarmFlag2.CommunicationError)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0417_CHILLER_COMMUNICATION_ERROR);
|
}
|
if (alarmFlag2.MemoryError)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0418_CHILLER_MEMORY_ERROR);
|
}
|
if (alarmFlag2.DcLineFuseCut)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0419_CHILLER_DC_LINE_FUSE_CUT);
|
}
|
if (alarmFlag2.CirculatingFluidDischargeTempSensorFailure)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0420_CHILLER_CIRCULATING_FLUID_DISCHARGE_TEMP_SENSOR_FAILURE);
|
}
|
if (alarmFlag2.CirculatingFluidReturnTempSensorFailure)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0421_CHILLER_CIRCULATING_FLUID_TEMP_SENSOR_FAILURE);
|
}
|
if (alarmFlag2.CompressorIntankTempSensorFailure)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0422_CHILLER_COMPRESSOR_INTANK_TEMP_SENSOR_FAILURE);
|
}
|
if (alarmFlag2.CirculatingFluidDischargePressureSensorFailure)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0423_CHILLER_CIRCULATING_FLUID_DISCHARGE_PRESSURE_SENSOR_FAILURE);
|
}
|
if (alarmFlag2.CompressorDischargePressureSensorFailure)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0424_CHILLER_COMPRESSOR_DISCHARGE_PRESSURE_SENSOR_FAILURE);
|
}
|
if (alarmFlag2.CompressorIntankPressureSensorFailure)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0425_CHILLER_COMPRESSOR_INTANK_PRESSURE_SENSOR_FAILURE);
|
}
|
if (alarmFlag2.MaintenanceOfPump)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0426_CHILLER_MAINTENANCE_OF_PUMP);
|
}
|
if (alarmFlag2.MaintenanceOfFanMotor)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0427_CHILLER_MAINTENENCE_OF_FAN_MOTOR);
|
}
|
if (alarmFlag2.MaintenanceOfCompressor)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0428_CHILLER_MAINTENENCE_OF_COMPRESSOR);
|
}
|
if (alarmFlag2.ContactInput1SignalDetectionAlarm)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0429_CHILLER_CONTACT_INPUT_1_SIGNAL_DETECTION_ALARM);
|
}
|
if (alarmFlag2.ContactInput2SignalDetectionAlarm)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0430_CHILLER_CONTACT_INPUT_2_SIGNAL_DETECTION_ALARM);
|
}
|
|
// Alarm 3
|
if(alarmFlag3.WaterLeakage)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0431_CHILLER_WATER_LEAKAGE);
|
}
|
if (alarmFlag3.ElectricResistivityConductivityLevelRise)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0432_CHILLER_ELECTRIC_RESISTIVITY_COMDUCTIVITY_LEVEL_RISE);
|
}
|
if (alarmFlag3.ElectricResistivityConductivityLevelDrop)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0433_CHILLER_ELECTRIC_RESISTIVITY_COMDUCTIVITY_LEVEL_DROP);
|
}
|
if (alarmFlag3.ElectricResistivityConductivitySensorError)
|
{
|
_equipment.alarmManager.Occur(AlarmCode.AL_0434_CHILLER_ELECTRIC_RESISTIVITY_COMDUCTIVITY_SENSOR_ERROR);
|
}
|
}
|
|
public byte GetLRC(byte[] datas)
|
{
|
byte LRC = 0x05;
|
|
return LRC;
|
}
|
}
|
}
|
