marekf/laatzen
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Rowlander
2021-10-01 11:09:20 +02:00
commit fe54fceb1e
1301 changed files with 853973 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Common/CordonelPreadjustmentUi/ZeroFlowGenesisMeter.cs
+414
View File
@@ -0,0 +1,414 @@
using CordonelPreadjustmentUi.Const;
using CordonelPreadjustmentUi.Helper;
using Logic.ProductionToProductMapper.Cordonel;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading;
using Logic.ProductionToProductMapper.Cordonel;
using Xylem.Common.CommonCore.Consts;
using Xylem.Common.Hardware.WaterMeter.Genesis.DataPackages.EventArguments;
using Xylem.Common.Hardware.WaterMeter.Genesis.DataPackages.MeasurementRecords;
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisConfig;
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisCore;
using Xylem.Common.Ui.CordonelPreadjustmentUi.Helper.Extensions;
namespace CordonelPreadjustmentUi
{
public class ZeroFlowGenesisMeter : GenesisMeter
{
#region Data logging
private bool logZeroFlow = false;
public bool logAmpTest = false;
#endregion
private CultureInfo GlobalCulture { get; set; }
public Byte Gp30LastByte { get; set; }
private Byte[] GP30LastRegister { get; set; }
public void SetGP30LastRegister(Byte[] data)
{
GP30LastRegister = data;
}
private Byte GP30LastPayloadLsb { get; set; }
public Byte GP30LastCommand { get; set; }
private Byte GP30RXPayload { get; set; }
private Boolean GP30RequestStarted { get; set; }
private Boolean GP30RequestFailed { get; set; }
private Boolean GP30RequestGotAnswer { get; set; }
private Byte Privilege { get; set; }
private Byte FirstHitLevelUpPath0 { get; set; }
private Byte FirstHitLevelUpPath1 { get; set; }
private Byte FirstHitLevelUpPath2 { get; set; }
private Byte FirstHitLevelDownPath0 { get; set; }
private Byte FirstHitLevelDownPath1 { get; set; }
private Byte FirstHitLevelDownPath2 { get; set; }
private Byte PercentPath0 { get; set; }
private Byte PercentPath1 { get; set; }
private Byte PercentPath2 { get; set; }
public Byte Subreason { get; set; }
private Byte Starthit { get; set; }
private Byte StoreCalibration { get; set; }
private Byte Amplitude { get; set; }
private Byte Samplerate { get; set; }
private UInt16 CalibrationFactorPath0 { get; set; }
private UInt16 CalibrationFactorPath1 { get; set; }
private UInt16 CalibrationFactorPath2 { get; set; }
private Int32 ZeroOffsetPath0 { get; set; }
private Int32 ZeroOffsetPath1 { get; set; }
private Int32 ZeroOffsetPath2 { get; set; }
private Byte LedMode { get; set; }
private Byte UpdatePeriode { get; set; }
private Byte FirstHitShift { get; set; }
private UInt32 ToFTempCalibrate { get; set; }
private Int32 ToFTempOffsetPath0 { get; set; }
private Int32 ToFTempOffsetPath1 { get; set; }
private Int32 ToFTempOffsetPath2 { get; set; }
public Int32 MeterNumber { get; set; }
private Byte MeterSize { get; set; }
public bool CalculationIndicatorZeroFlowTest { get; private set; }
public bool LoggingIndicatorZeroFlowTest { get; private set; }
public long ZeroflowOffsetTestNumberOfLines { get; private set; }
public Boolean LogOnEnable;
public Boolean AmplitudeEnable;
public Boolean ZeroFlowOffsetEnable;
public Boolean TempCalEnable;
public Boolean CompletionEnable;
public Boolean LoginFailed;
public Boolean PreparationFailed;
public Boolean AmplitudeFailed;
public Boolean ZeroFlowOffsetFailed;
public Boolean TempCalFailed;
public Boolean CompletionFailed;
public Boolean Ok;
public Boolean EmptyPipeCheckEnable;
public Boolean EmptyPipeCheckFailed;
public Boolean MeterSelected;
public CalibrationResult calibrationResult = new CalibrationResult();
public ConcurrentQueue<CalibrationRecord> CurrentRecords = new ConcurrentQueue<CalibrationRecord>();
public ZeroFlowGenesisMeter(int Slot, int PathsCount = 3, bool ignorCurruptdata = true) : base()
{
base.SetupFromConfigFile(Slot, ignorCurruptdata);
//base.EnableAutoLogon();
Setup(PathsCount);
//on zeroflow every param has to be stored
_configuration.UseRegisterWatchService = true;
_configuration.RegisterWatchServiceUrl = Xylem.Common.CommonCore.Configuration.ServiceUrls.RegisterWatchServiceUrl();
}
public ZeroFlowGenesisMeter(int Slot, int PathsCount, PortConfig request, PortConfig streaming, bool ignoreCurrptData) : base()
{
base.SetupGenesisMeter(Slot, request, streaming, ignoreCurrptData);
// base.EnableAutoLogon();
Setup(PathsCount);
//overide register watch service
//on zeroflow every param has to be stored
_configuration.UseRegisterWatchService = true;
}
private void Setup(int PathsCount)
{
base.LogRawData(true);
this.GP30LastRegister = new Byte[2] { 0, 0 };
this.GP30LastPayloadLsb = 0;
this.GP30LastCommand = 0;
this.GP30RXPayload = 0;
this.GP30RequestStarted = false;
this.GP30RequestFailed = false;
this.GP30RequestGotAnswer = false;
this.FirstHitLevelUpPath0 = 0;
this.FirstHitLevelUpPath1 = 0;
this.FirstHitLevelUpPath2 = 0;
this.FirstHitLevelDownPath0 = 0;
this.FirstHitLevelDownPath1 = 0;
this.FirstHitLevelDownPath2 = 0;
this.Starthit = 0;
this.Amplitude = 0;
this.Samplerate = 0;
this.CalibrationFactorPath0 = 0;
this.CalibrationFactorPath1 = 0;
this.CalibrationFactorPath2 = 0;
this.ZeroOffsetPath0 = 0;
this.ZeroOffsetPath1 = 0;
this.ZeroOffsetPath2 = 0;
this.LedMode = 0;
this.MeterNumber = Slot;
this.GlobalCulture = CultureInfo.CreateSpecificCulture("en-US");
this.Gp30LastByte = 0;
linesRecived = new MultiPathDataLogContainer<Int64>(PathsCount);
listOfTotalTimeOfFlightSPerPath = new ActivityCheckMultiPathDataLogContainer<List<Double>>(PathsCount);
listOfTotalTimeOfFlightSPerPath.Update(null, new List<Double>());
BadDataCounterZeroFlowTest = new MultiPathDataLogContainer<Int64>(PathsCount);
LineCounterZeroFlowTest = new MultiPathDataLogContainer<Int64>(PathsCount);
AmplitudeValuesUp = new MultiPathDataLogContainer<List<double>>(PathsCount);
AmplitudeValuesDown = new MultiPathDataLogContainer<List<double>>(PathsCount);
DeltaTimeOfFlightAverage = new MultiPathDataLogContainer<List<double>>(PathsCount);
Decoded = new MultiPathDataLogContainer<CalibrationRecord>(PathsCount);
}
public Boolean CheckStreamingPort()
{
if (!StreamingPort.IsOpen())
{
base.StreamingPort.Open();
}
return StreamingPort.IsOpen();
}
public Boolean CheckRequestPort()
{
if (!RequestPort.IsOpen())
{
base.RequestPort.Open();
}
return RequestPort.IsOpen();
}
public void StartRecordData(int zeroflowOffsetTestNumberOfLines = 0)
{
CurrentRecords.Clear();
StreamingProtocol.OnRecordIsDecoded += StreamingProtocol_OnRecordIsDecoded; ;
SyncStreamingBuffer(SyncMarkRecord.DecodeEveryPackage);
ZeroflowOffsetTestNumberOfLines = zeroflowOffsetTestNumberOfLines;
}
private List<string> logContent = new List<String>();
public ActivityCheckMultiPathDataLogContainer<List<double>> listOfTotalTimeOfFlightSPerPath;
private MultiPathDataLogContainer<Int64> linesRecived;
private MultiPathDataLogContainer<Int64> BadDataCounterZeroFlowTest;
private MultiPathDataLogContainer<Int64> LineCounterZeroFlowTest;
private MultiPathDataLogContainer<List<double>> AmplitudeValuesUp;
private MultiPathDataLogContainer<List<double>> AmplitudeValuesDown;
private MultiPathDataLogContainer<List<double>> DeltaTimeOfFlightAverage;
private MultiPathDataLogContainer<CalibrationRecord> Decoded;
internal void DataLog(string text)
{
logContent.Add(text);
//todo nlog!
}
private void StreamingProtocol_OnRecordIsDecoded(object sender, BaseDataEventArgs e)
{
try
{
if (e is CalibDataEventArgs)
{
var decodedDate = (CalibDataEventArgs)e;
var data = decodedDate.CalibChl;
if (Slot == 10 && data.Channel == 2)
{
String time = DateTime.Now.ToString(Formats.RawDataDateTimeLogString);
DataLog($"{time} {decodedDate.RawData}\n");
}
CurrentRecords.Enqueue(data);
//todo make new imesturementrecord according to units need by zeroflow app
var TotalTimeOfFlightS = data.TotalTimeOfFlightS * 1000000;
Double temp = data.DeltaTimeOfFlightS;
//data.DeltaTimeOfFlightS = data.DeltaTimeOfFlightS * (1.0 / 0x4000000000); // 2^38;
data.AmplitudeUpV = data.AmplitudeUpV * 1000.0;
data.AmplitudeDownV = data.AmplitudeDownV * 1000.0;
#region Logging (Zero flow test)
if (logZeroFlow || logAmpTest)
{
String time = DateTime.Now.ToString(Formats.RawDataDateTimeLogString);
DataLog($"{time} {decodedDate.RawData}\n");
}
#endregion
#region Add to list h-protocol
UInt16 Path = (UInt16)(decodedDate.CalibChl.Channel - 1);
//todo check if isValid == crc Ok
if (decodedDate.CalibChl.IsValid)
{
#region Activity check for empty pipe test
linesRecived.Update(Path, linesRecived.Get(Path) + 1);
#endregion
#region Data for amplitude test
if (logAmpTest)
{
DataLog($"Add {TotalTimeOfFlightS} for chnl {Path}\n");
var tmp = listOfTotalTimeOfFlightSPerPath.Get(Path).ToList();
tmp.Add(TotalTimeOfFlightS);
listOfTotalTimeOfFlightSPerPath.Update(Path, tmp);
}
#endregion
#region Data for zero flow test
var meterDone = true;
for (int i = 0; i < LineCounterZeroFlowTest.GetPathCount(); i++)
{
if (LineCounterZeroFlowTest.Get(i) < ZeroflowOffsetTestNumberOfLines)
{
meterDone = false;
}
}
if (meterDone)
{
CalculationIndicatorZeroFlowTest = false;
LoggingIndicatorZeroFlowTest = false;
}
if (CalculationIndicatorZeroFlowTest)
{
#region Bad data check
if (decodedDate.CalibChl.Validation == DataErrorCodes.NoError)
{
AmplitudeValuesUp.Get(Path).Add(decodedDate.CalibChl.AmplitudeUpV);
AmplitudeValuesDown.Get(Path).Add(decodedDate.CalibChl.AmplitudeDownV);
DeltaTimeOfFlightAverage.Get(Path).Add(decodedDate.CalibChl.DeltaTimeOfFlightS);
LineCounterZeroFlowTest.Update(Path, LineCounterZeroFlowTest.Get(Path) + 1);
}
else
{
BadDataCounterZeroFlowTest.Update(Path, BadDataCounterZeroFlowTest.Get(Path) + 1);
}
#endregion
}
#endregion
}
#endregion
#region Copy to global object
Decoded.Update(Path, data);
#endregion
}
}
catch (Exception ex)
{
DataLog($"Exception occur {e}\n");
}
}
public void StopRecordData()
{
StreamingProtocol.OnRecordIsDecoded -= StreamingProtocol_OnRecordIsDecoded;
SyncStreamingBuffer(SyncMarkRecord.SkipDecoding);
}
internal void Flush()
{
if (StreamingPort == null)
{
throw new ApplicationException("Synchronization not possible due to undefined streaming port");
}
SyncStreamingBuffer(SyncMarkRecord.FlushBuffer);
}
public new Boolean WriteRegisterUnsafe<T>(string reg, T value)
{
var RetrysLeft = 12;
while (RetrysLeft >= 0)
{
try
{
var result = base.WriteRegister(reg, value, true, false);
if (result)
{
return result;
}
Thread.Sleep(1500);
}
catch (Exception e)
{
base.WriteLog($"Can not WriteRegisterUnsafe retry left: {RetrysLeft}, message: {e.Message}");
}
RetrysLeft = RetrysLeft - 1;
}
return false;
}
public new Boolean WriteRegisterSafe<T>(string reg, T value)
{
var RetrysLeft = 12;
while (RetrysLeft >= 0)
{
try
{
var result = base.WriteRegister(reg, value, true, true);
if (result)
{
return result;
}
Thread.Sleep(1500);
}
catch (Exception e)
{
base.WriteLog($"Can not WriteRegisterUnsafe retry left: {RetrysLeft}, message: {e.Message}");
}
RetrysLeft = RetrysLeft - 1;
}
return false;
}
public new Byte[] ReadRegister(string reg)
{
var RetrysLeft = 12;
Exception lastEx = null;
while (RetrysLeft >= 0)
{
try
{
return base.ReadRegister(reg);
}
catch (Exception e)
{
lastEx = e;
base.WriteLog($"Can not WriteRegisterUnsafe retry left: {RetrysLeft}, message: {e.Message}");
}
Thread.Sleep(1500);
RetrysLeft = RetrysLeft - 1;
}
if (lastEx == null)
{
throw new ApplicationException("something went totally wrong on ReadRegister. no Exception found");
}
throw new ApplicationException($"something went wrong on ReadRegister.Message{lastEx.Message}");
}
}
}