548 lines
16 KiB
C#
548 lines
16 KiB
C#
///
|
|
/// Copyright (c) 2015-2018 Sensus Slovensko a.s.
|
|
///
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.IO.Ports;
|
|
using System.Threading;
|
|
using System.Windows.Forms;
|
|
using log4net;
|
|
using Config.Entities;
|
|
using TBF.BenchControl;
|
|
using TBF.BenchControl.Generic;
|
|
using TBF.Resources;
|
|
using Xylem.Common.Hardware.WaterMeter;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis;
|
|
using TBF.BenchControl.GenericDevices;
|
|
|
|
namespace TBF.BenchControl.TestMethods.GenesisCommunication.GenesisHead
|
|
{
|
|
public static class GenesisHeadBatch
|
|
{
|
|
public static readonly Lazy<MeterBatch> BatchHolder = new Lazy<MeterBatch>(() =>
|
|
{
|
|
return new MeterBatch();
|
|
});
|
|
|
|
internal static bool Start(IRegisterReader[] registerReaders, string[] lastSNTexts)
|
|
{
|
|
int index = 0;
|
|
var ret = false;
|
|
foreach (var rr in registerReaders)
|
|
{
|
|
if (rr is TestMethods.GenesisCommunication.GenesisHead.GenesisHead)
|
|
{
|
|
if (!string.IsNullOrEmpty(lastSNTexts[index]))
|
|
{
|
|
var myGenesis = ((TestMethods.GenesisCommunication.GenesisHead.GenesisHead)rr).SetUp();
|
|
ret = true;
|
|
}
|
|
}
|
|
index = index + 1;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// This component = instance of this class is a placeholder for a combined main watermeter
|
|
/// </summary>
|
|
public class GenesisHead : ComponentBase, IDevice, GenericDevices.IRegisterReader, IOperation
|
|
{
|
|
private static readonly ILog log = LogManager.GetLogger(typeof(GenesisHead));
|
|
public override string ToString() { return string.Format("Genesis({0})", Cfg.ToString(1)); }
|
|
|
|
|
|
readonly GenesisHeadCfg genesisHeadCfg;
|
|
public int SlotNr { get { return genesisHeadCfg.SlotNr; } }
|
|
public double PulsesPerLtr { get { return 1000.0; } }
|
|
public double LtrsPerPulse { get { return 1 / PulsesPerLtr; } }
|
|
|
|
#if ORACLE_DB
|
|
public int WMType_ID { get { return iperlHeadCfg.ProcParams.WMType_ID; } } /// Required by Oracle DB
|
|
public int WMType_Rev { get { return iperlHeadCfg.ProcParams.WMType_Rev; } } /// Required by Oracle DB
|
|
#endif
|
|
public float CalibTarget { get { return (ushort)genesisHeadCfg.ProcParams.CalibTarget; } }
|
|
public ushort FactorLimitLo { get { return (ushort)genesisHeadCfg.ProcParams.FactorLimitLo; } }
|
|
public ushort FactorLimitHi { get { return (ushort)genesisHeadCfg.ProcParams.FactorLimitHi; } }
|
|
|
|
/// Properties set by the Begin and the End form
|
|
//todo rd implement
|
|
public string SerialNr;
|
|
|
|
|
|
public string EndState
|
|
{
|
|
get { return endState; }
|
|
set { endState = value; }
|
|
}
|
|
string endState;
|
|
|
|
public string BeginState
|
|
{
|
|
get { return beginState; }
|
|
set { beginState = value; }
|
|
}
|
|
string beginState;
|
|
|
|
public bool Disabled
|
|
{
|
|
get { return disabled; }
|
|
set { disabled = value; }
|
|
}
|
|
bool disabled;
|
|
|
|
public bool CommFailed
|
|
{
|
|
get { return commFailed; }
|
|
set { commFailed = value; }
|
|
}
|
|
bool commFailed;
|
|
|
|
public int ResultCode
|
|
{
|
|
get { return resultCode; }
|
|
}
|
|
int resultCode;
|
|
|
|
|
|
/// <summary> ConfigStruct of the water meter obtained or updated by iPerlCommunication </summary>
|
|
public ConfigStruct ConfigStruct
|
|
{
|
|
get { return configStruct; }
|
|
set { configStruct = value; }
|
|
}
|
|
ConfigStruct configStruct;
|
|
|
|
/// <summary> CalibrationStruct of the water meter obtained or updated by iPerlCommunication </summary>
|
|
public CalibrationStruct CalibrationStruct
|
|
{
|
|
get { return calibrationStruct; }
|
|
set { calibrationStruct = value; }
|
|
}
|
|
CalibrationStruct calibrationStruct;
|
|
|
|
public ushort OrigCalibFactor;
|
|
public ushort CalibFactor { get { return (CalibrationStruct != null) ? CalibrationStruct.Calibration : (ushort)0; } }
|
|
|
|
public double Q2ErrWOCorrection;
|
|
public bool Q2CorrectionDone;
|
|
public double Q2Correction;
|
|
public int Q2CorrRFlow;
|
|
public int Q2CorrLFlow;
|
|
|
|
public double Diff2Hz8Hz;
|
|
public bool Hz2CorrectionDone;
|
|
public int Hz2Correction;
|
|
|
|
public string FWVersion { get { return (CalibrationStruct != null) ? CalibrationStruct.FWVersionStr() : string.Empty; } }
|
|
|
|
|
|
/// <summary> Result of the last test used to calculate Q2 correction factors, etc </summary>
|
|
public Results.Entities.MeterTestRslt LastTestResult2;
|
|
public Results.Entities.MeterTestRslt LastTestResult;
|
|
public double NominalTestFlowLph; /// in liter per hour
|
|
|
|
|
|
///
|
|
/// Required for IRegisterReader interface
|
|
///
|
|
public int WMPulses { get { return wmPulses; } }
|
|
public int WMRefPulses { get { return wmRefPulses; } }
|
|
public double WMVolume { get { return wmVolume; } }
|
|
public double BeginWMState { get { return beginWMState; } }
|
|
public double EndWMState { get { return endWMState; } }
|
|
public double WMTestTime { get { return wmTestTime; } }
|
|
|
|
|
|
double beginWMState;
|
|
double endWMState;
|
|
double wmVolume;
|
|
int wmPulses;
|
|
int wmRefPulses;
|
|
double wmTestTime;
|
|
|
|
|
|
/// <summary> Name set by the test, to be used as a part of the opto-data log file name </summary>
|
|
public string TestName;
|
|
|
|
/// <summary> Name set by the test, to be used as a part of the opto-data log file name </summary>
|
|
public string BenchName;
|
|
|
|
///
|
|
/// Volume of water from the opto telegram
|
|
///
|
|
private Int64 lastVolumeRaw; /// Last read raw volume
|
|
private double volumeLtr; ///
|
|
private double volumeLtr0;
|
|
|
|
|
|
///
|
|
/// Timestamp from the opto telegram
|
|
///
|
|
private double timestampSec;
|
|
private double timestampSec0;
|
|
|
|
public bool NoSamples { get { return (timestampSecEnd - timestampSecStart) < float.Epsilon; } }
|
|
public double TimestampSecStart { get { return timestampSecStart; } }
|
|
public double TimestampSecEnd { get { return timestampSecEnd; } }
|
|
double timestampSecStart;
|
|
double timestampSecEnd;
|
|
|
|
public GenesisHead()
|
|
{
|
|
}
|
|
|
|
public GenesisHead(Generic.IComponentCfg cfg)
|
|
: base(cfg)
|
|
{
|
|
ClearData();
|
|
|
|
genesisHeadCfg = cfg as GenesisHeadCfg;
|
|
|
|
log.Debug(this.ToString());
|
|
}
|
|
|
|
|
|
GenesisMeter myGenesis = null;
|
|
|
|
|
|
|
|
|
|
|
|
public GenesisMeter SetUp()
|
|
{
|
|
if (myGenesis != null)
|
|
{
|
|
myGenesis.DisposeMeter();
|
|
}
|
|
//add for gen
|
|
|
|
myGenesis = new GenesisMeter();
|
|
myGenesis.SetupFromConfigFile(SlotNr);
|
|
|
|
GenesisHeadBatch.BatchHolder.Value.AddMeter(myGenesis);
|
|
myGenesis.LogRawData(true);
|
|
return myGenesis;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clear data related to a specific water meter
|
|
/// </summary>
|
|
public void ClearData()
|
|
{
|
|
resultCode = 0;
|
|
|
|
disabled = false;
|
|
commFailed = false;
|
|
endState = string.Empty;
|
|
beginState = string.Empty;
|
|
|
|
configStruct = null;
|
|
calibrationStruct = null;
|
|
|
|
LastTestResult = null;
|
|
NominalTestFlowLph = 0;
|
|
|
|
OrigCalibFactor = 0;
|
|
Q2ErrWOCorrection = 0;
|
|
Q2CorrectionDone = false;
|
|
Q2CorrRFlow = 0;
|
|
}
|
|
|
|
public void Initialize()
|
|
{
|
|
ClearData();
|
|
|
|
if (DebugLevel == DebugMode.Normal)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
public void RunDeviceBefore()
|
|
{
|
|
|
|
|
|
////todo: RD- Login??
|
|
//if (DebugLevel == DebugMode.Normal)
|
|
//{
|
|
|
|
|
|
// if (myGenesis != null)
|
|
// {
|
|
// Log("TBF RunDeviceBefore");
|
|
// //myGenesis.Login();
|
|
// //myGenesis.InitMeasurement();
|
|
// }
|
|
// else
|
|
// {
|
|
// throw new Exception("No meter was bound!");
|
|
// }
|
|
//}
|
|
//else if (DebugLevel == DebugMode.FailureDuringOperation)
|
|
//{
|
|
//}
|
|
}
|
|
|
|
public void RunDeviceAfter() { }
|
|
|
|
public void StopDevice()
|
|
{
|
|
try
|
|
{
|
|
|
|
if (DebugLevel == DebugMode.Normal && myGenesis != null)
|
|
{
|
|
myGenesis.DisposeMeter();
|
|
|
|
GenesisHeadBatch.BatchHolder.Value.RemoveMeter(myGenesis);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
public void StopDevice2() { }
|
|
|
|
/// <summary>
|
|
/// Events: Event.ReadRegisterDone, Event.Error
|
|
/// </summary>
|
|
/// <returns>ReadWaterMeter instance reference casted to IOperaton</returns>
|
|
public IOperation ReadRegisterOp()
|
|
{
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clear data/counters related to a specific tests
|
|
/// </summary>
|
|
public void Clear()
|
|
{
|
|
resultCode = 0;
|
|
|
|
sampleNr = 0;
|
|
|
|
volumeLtr = 0;
|
|
volumeLtr0 = 0;
|
|
timestampSec = 0;
|
|
timestampSec0 = 0;
|
|
|
|
ReadPulses();
|
|
}
|
|
|
|
public void TestCompleted()
|
|
{
|
|
/// TODO: Implement
|
|
}
|
|
|
|
|
|
int sampleNr; /// This is to determine when the test start sample should be taken
|
|
bool StoreStartPackage = false;
|
|
bool StoreEndPackage = false;
|
|
bool Enable = false;
|
|
public bool IsCalibration = false;
|
|
/// <summary>Start this operation</summary>
|
|
public void Start()
|
|
{
|
|
|
|
|
|
}
|
|
public void StartRead(string TestName)
|
|
{
|
|
StoreStartPackage = false;
|
|
StoreEndPackage = false;
|
|
//Start mesurement
|
|
if (DebugLevel == DebugMode.Normal)
|
|
{
|
|
if (myGenesis != null)
|
|
{
|
|
IsCalibration = false;
|
|
Log("TBF Start Measurement");
|
|
if (TestName.ToLower().Contains("calib"))
|
|
{
|
|
IsCalibration = true;
|
|
myGenesis.StartCalibration();
|
|
}
|
|
else
|
|
{
|
|
myGenesis.StartMeasurement();
|
|
}
|
|
|
|
StoreStartPackage = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Log(string text)
|
|
{
|
|
if (DebugLevel == DebugMode.Normal)
|
|
{
|
|
if (myGenesis != null)
|
|
{
|
|
myGenesis.WriteLog(text);
|
|
}
|
|
}
|
|
}
|
|
void readOutResults(Xylem.Common.Hardware.WaterMeter.CommonMeterDefinitions.MeasurementResults results)
|
|
{
|
|
|
|
//if (StoreStartPackage)
|
|
//{
|
|
|
|
// volumeLtr0 = results.StartData.GetVolumeQm() * 1000;
|
|
// timestampSec0 = results.StartData.GetTimeS();
|
|
// StoreStartPackage = false;
|
|
//}
|
|
//else if (!StoreEndPackage)
|
|
//{
|
|
|
|
volumeLtr = results.EndData.GetVolumeQm() * 1000;
|
|
timestampSec = results.EndData.GetTimeS();
|
|
wmTestTime = results.TotalTimeS;
|
|
wmVolume = results.TotalVolumeQm * 1000;
|
|
ReadPulses();
|
|
//}
|
|
|
|
|
|
}
|
|
|
|
/// <summary>Run this operation</summary>
|
|
/// <returns>eventDone</returns>
|
|
public Event Run()
|
|
{
|
|
if (DebugLevel == DebugMode.Normal)
|
|
{
|
|
if (myGenesis != null)
|
|
{
|
|
try
|
|
{
|
|
//var results = myGenesis.GetIntermediateMeasurementResult();
|
|
//readOutResults(results);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return Event.ReadRegisterDone;
|
|
}
|
|
public double RefVolume = 0.0;
|
|
|
|
public void Stop()
|
|
{
|
|
//Stop(null);
|
|
if (DebugLevel == DebugMode.Normal && myGenesis != null)
|
|
{
|
|
if (IsCalibration)
|
|
{
|
|
myGenesis.StopCalibration();
|
|
}
|
|
else
|
|
{
|
|
myGenesis.StopMeasurement();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>Stop this operation</summary>
|
|
public void Stop(Double? testTimeS = null)
|
|
{
|
|
|
|
if (DebugLevel == DebugMode.Normal && myGenesis != null)
|
|
{
|
|
Log("TBF Stop Measurement");
|
|
if (IsCalibration)
|
|
{
|
|
//myGenesis.StopCalibration();
|
|
int retryCounter = 400;
|
|
while (myGenesis.GetCalibrationState() != Xylem.Common.Hardware.WaterMeter.CommonMeterDefinitions.ActionStates.IsCompleted)
|
|
{
|
|
if (retryCounter < 0)
|
|
{
|
|
break;
|
|
}
|
|
Thread.Sleep(10);
|
|
retryCounter = retryCounter - 1;
|
|
}
|
|
try
|
|
{
|
|
var results = myGenesis.GetCalibrationResult();
|
|
readOutResults(results[0]);
|
|
if (RefVolume != 0.0)
|
|
{
|
|
myGenesis.CalculateCalibrationWithVol(RefVolume,0);
|
|
myGenesis.SaveCalculatedCalibration(false);
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MarkAsError();
|
|
Log("Error while Stop Calib " + ex.Message);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int retryCounter = 400;
|
|
//myGenesis.StopMeasurement();
|
|
while (myGenesis.GetMeasurementState() != Xylem.Common.Hardware.WaterMeter.CommonMeterDefinitions.ActionStates.IsCompleted)
|
|
{
|
|
if (retryCounter < 0)
|
|
{
|
|
break;
|
|
}
|
|
Thread.Sleep(10);
|
|
retryCounter = retryCounter - 1;
|
|
}
|
|
try
|
|
{
|
|
var results = myGenesis.GetMeasurementResult(testTimeS);
|
|
readOutResults(results);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MarkAsError();
|
|
Log("Error while Stop Measurement " + ex.Message);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
StoreEndPackage = true;
|
|
|
|
}
|
|
}
|
|
void MarkAsError()
|
|
{
|
|
volumeLtr = 100;
|
|
timestampSec = 1;
|
|
wmTestTime = 1;
|
|
wmVolume = 100;
|
|
ReadPulses();
|
|
}
|
|
|
|
void ReadPulses()
|
|
{
|
|
beginWMState = volumeLtr0;
|
|
endWMState = volumeLtr;
|
|
wmPulses = (int)(wmVolume * (double)PulsesPerLtr + 0.5);
|
|
wmRefPulses = StateMachine.ControlBoard.EtPulses(0);
|
|
}
|
|
|
|
|
|
bool optoSerialPortParsingEnabled;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
}
|