using System; using System.Collections.Generic; using System.Linq; using System.Globalization; using System.Threading.Tasks; using System.Windows.Forms; using System.Diagnostics; using System.IO; using GenesisDisplayTool; using System.Collections.Concurrent; using GenesisDisplayTool.Itinerary; using Xylem.Common.Hardware.WaterMeter.WaterMeterCore; using Xylem.Common.Ui.GenesisToolBox; using Xylem.Common.CommonCore.Consts; using Xylem.Common.Hardware.WaterMeter.Genesis.DataPackages.MeasurementRecords; using System.Drawing; using System.Threading; namespace GenesisZeroFlow { public partial class GenesisZeroFlow : Form { //UInt16 ScrRes = CultureInfo CultureDe = CultureInfo.CreateSpecificCulture("de-DE"); CultureInfo CultureEn = CultureInfo.CreateSpecificCulture("en-US"); public CultureInfo GetGlobalCulture() { Int32 Index = GetSelectedLanguageIndex(); if (Int32.Equals(Index, 0)) return CultureDe; else return CultureEn; } public Int32 GetSelectedLanguageIndex() { Int32 temp = 0; if (InvokeRequired) { lbLanguage.Invoke(new Action(() => { temp = lbLanguage.SelectedIndex; })); return temp; } return lbLanguage.SelectedIndex; } public Double GetUpperTempLimit() { Double temp = 0; if (InvokeRequired) { nUD_SettingsTempMonitorUpperValue.Invoke(new Action(() => { temp = (Double)nUD_SettingsTempMonitorUpperValue.Value; })); return temp; } return (Double)nUD_SettingsTempMonitorUpperValue.Value; } public Double GetLowerTempLimit() { Double temp = 0; if (InvokeRequired) { nUD_SettingsTempMonitorLowerValue.Invoke(new Action(() => { temp = (Double)nUD_SettingsTempMonitorLowerValue.Value; })); return temp; } return (Double)nUD_SettingsTempMonitorLowerValue.Value; } public Double GetTempDeviationLimit() { Double temp = 0; if (InvokeRequired) { nUD_SettingsTempMonitorDeviation.Invoke(new Action(() => { temp = (Double)nUD_SettingsTempMonitorDeviation.Value; })); return temp; } return (Double)nUD_SettingsTempMonitorDeviation.Value; } public String GetLoggingFromTextBox() { String temp = String.Empty; if (InvokeRequired) { rTB_ZeroFlowCal.Invoke(new Action(() => { temp = rTB_ZeroFlowCal.Text; })); return temp; } return rTB_ZeroFlowCal.Text; } #region Object declarations CmdInterface CommandInterface1 = new CmdInterface(); CmdInterface CommandInterface2 = new CmdInterface(); CmdInterface CommandInterface3 = new CmdInterface(); CmdInterface CommandInterface4 = new CmdInterface(); CmdInterface CommandInterface5 = new CmdInterface(); CmdInterface CommandInterface6 = new CmdInterface(); CmdInterface CommandInterface7 = new CmdInterface(); CmdInterface CommandInterface8 = new CmdInterface(); CmdInterface CommandInterface9 = new CmdInterface(); CmdInterface CommandInterface10 = new CmdInterface(); #endregion #region Global parameters public String[] PcbID = new String[Constants.NumberOfMeters] { String.Empty, String.Empty, String.Empty, String.Empty, String.Empty, String.Empty, String.Empty, String.Empty, String.Empty, String.Empty }; public String[] ThermoID = new String[Constants.NumberOfThermometers] { String.Empty, String.Empty }; private List[][] AmplitudeValuesUp = new List[Constants.NumberOfMeters][]; private List[][] AmplitudeValuesDown = new List[Constants.NumberOfMeters][]; private List[][] totalTimeOfFlightAverage = new List[Constants.NumberOfMeters][]; //private List[][] Temperatures = new List[Constants.NumberOfThermometers][]; class tempHelper { public int meter; public int channel; ConcurrentStack values = new ConcurrentStack(); public Double getAvg() { var list = values.ToList(); if (!list.Any()) return 0; var a = list.Average(); values = new ConcurrentStack(); return a; } public void add(Double v) { values.Push(v); } } private ConcurrentBag TemperaturesThreadSafe = new ConcurrentBag(); private void BagDemo() { //init TemperaturesThreadSafe.Add(new tempHelper() { channel = 1, meter = 2 }); //add TemperaturesThreadSafe.Where(t => t.meter.Equals(2) && t.channel.Equals(1)).First().add(1); // get avg TemperaturesThreadSafe.Where(t => t.meter.Equals(2) && t.channel.Equals(1)).First().getAvg(); } public List[][] GetTotalTimeOfFlightAverage() { return (List[][])totalTimeOfFlightAverage.Clone(); } public void InitTemperatures() { for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++) { TemperaturesThreadSafe.Add(new tempHelper() { channel = Path, meter = Constants.Thermo1 }); TemperaturesThreadSafe.Add(new tempHelper() { channel = Path, meter = Constants.Thermo2 }); } } public Double GetTemperatures(UInt16 Thermo, UInt16 Path) { return TemperaturesThreadSafe.Where(t => t.meter.Equals(Thermo) && t.channel.Equals(Path)).First().getAvg(); } public void SetTemperatures(UInt16 Thermo, UInt16 Path, Double value) { TemperaturesThreadSafe.Where(t => t.meter.Equals(Thermo) && t.channel.Equals(Path)).First().add(value); } public void ClearTotalTimeOfFlightAverage(UInt16 meterNumber, UInt16 path) { totalTimeOfFlightAverage[meterNumber][path].Clear(); } private List[][] DeltaTimeOfFlightAverageRAW = new List[Constants.NumberOfMeters][]; private List[][] DeltaTimeOfFlightAverage = new List[Constants.NumberOfMeters][]; private String[] dataToLog = new String[Constants.NumberOfMeters]; public void SetDataToLog(UInt16 meterNumber, String data) { dataToLog[meterNumber] = data; } public String[] GetDataToLog() { return (String[])dataToLog.Clone(); } private String[][] AmpValuesToLog = new String[Constants.NumberOfMeters][]; public String[][] GetAmpValuesToLog() { return (String[][])AmpValuesToLog.Clone(); } public void SetAmpValuesToLog(UInt16 meterNumber, UInt16 path, String data) { AmpValuesToLog[meterNumber][path] = data; } private Boolean[] loggingIndicatorZeroFlowTest = new Boolean[Constants.NumberOfMeters]; public void SetLoggingIndicatorZeroFlowTest(Boolean value, UInt16 meterNumber) { loggingIndicatorZeroFlowTest[meterNumber] = value; } public Boolean[] GetLoggingIndicatorZeroFlowTest() { return (Boolean[])loggingIndicatorZeroFlowTest.Clone(); } private Boolean[] calculationIndicatorZeroFlowTest = new Boolean[Constants.NumberOfMeters]; public void SetCalculationIndicatorZeroFlowTest(Boolean value, UInt16 meterNumber) { calculationIndicatorZeroFlowTest[meterNumber] = value; } public Boolean[] GetCalculationIndicatorZeroFlowTest() { return (Boolean[])calculationIndicatorZeroFlowTest.Clone(); } private String[] LoggingPathZeroFlowTest = new String[Constants.NumberOfMeters]; public String[] GetLoggingPathZeroFlowTest() { return (String[])LoggingPathZeroFlowTest.Clone(); } public void SetLoggingPathZeroFlowTest(UInt16 meterNumber, String data) { LoggingPathZeroFlowTest[meterNumber] = data; } private Int32[][] BadDataCounterZeroFlowTest = new Int32[Constants.NumberOfMeters][]; private Int32[][] LineCounterZeroFlowTest = new Int32[Constants.NumberOfMeters][]; public void SetLineCounterZeroFlowTest(UInt16 meterNumber, UInt16 path, Int32 data) { LineCounterZeroFlowTest[meterNumber][path] = data; } private Boolean[][] NewDataIndicatorTemperatureTest = new Boolean[Constants.NumberOfThermometers][]; private Boolean[] StartLoggingIndicatorAmplitudeTest = new Boolean[Constants.NumberOfMeters]; private Boolean[] LoggingIndicatorAmpTest = new Boolean[Constants.NumberOfMeters]; private Boolean[] TofIndicatorAmplitudeTest = new Boolean[Constants.NumberOfMeters]; private Boolean[] LoggingIndicatorThermoMonitoring = new Boolean[Constants.NumberOfThermometers]; public Boolean GetNewDataIndicatorTemperatureTest(UInt16 thermo, UInt16 path) { return NewDataIndicatorTemperatureTest[thermo][path]; } public void SetLoggingIndicatorThermoMonitoring(UInt16 thermoNumber, Boolean value) { if (thermoNumber < Constants.NumberOfThermometers) LoggingIndicatorThermoMonitoring[thermoNumber] = value; } public Boolean[] GetLoggingIndicatorThermoMonitoring() { return LoggingIndicatorThermoMonitoring; } public void SetLoggingIndicatorAmpTest(UInt16 meterNumber, Boolean value) { if (meterNumber < Constants.NumberOfMeters) LoggingIndicatorAmpTest[meterNumber] = value; } public Boolean[] GetTofIndicatorAmplitudeTest() { return TofIndicatorAmplitudeTest; } public void SetTofIndicatorAmplitudeTest(UInt16 meterNumber, Boolean value) { if (meterNumber < Constants.NumberOfMeters) TofIndicatorAmplitudeTest[meterNumber] = value; } public Boolean[] GetLoggingIndicatorAmpTest() { return LoggingIndicatorAmpTest; } private Boolean[] IndicatorTemperatureActivityCheck = new Boolean[Constants.NumberOfThermometers]; public void SetIndicatorTemperatureActivityCheck(UInt16 thermoNumber, Boolean value) { if (thermoNumber < Constants.NumberOfThermometers) IndicatorTemperatureActivityCheck[thermoNumber] = value; } private Boolean[] LoggingIndicatorEmptyPipeTest = new Boolean[Constants.NumberOfMeters]; public void SetLoggingIndicatorEmptyPipeTest(UInt16 meterNumber, Boolean value) { if (meterNumber < Constants.NumberOfMeters) LoggingIndicatorEmptyPipeTest[meterNumber] = value; } private Boolean[] LoggingIndicatorThermoEmptyPipeTest = new Boolean[Constants.NumberOfThermometers]; public void SetLoggingIndicatorThermoEmptyPipeTest(UInt16 thermoNumber, Boolean value) { if (thermoNumber < Constants.NumberOfThermometers) LoggingIndicatorThermoEmptyPipeTest[thermoNumber] = value; } private String[] LoggingPathAmplitudeTest = new String[Constants.NumberOfMeters]; public String[] GetLoggingPathAmplitudeTest() { return (String[])LoggingPathAmplitudeTest.Clone(); } public void SetLoggingPathAmplitudeTest(UInt16 meterNumber, String data) { LoggingPathAmplitudeTest[meterNumber] = data; } private Int32[][] LineCounterAmplitudeTest = new Int32[Constants.NumberOfMeters][]; public Int32[][] GetLineCounterAmplitudeTest() { return (Int32[][])LineCounterAmplitudeTest; } private Int32[][] LineCounterEmptyPipeTest = new Int32[Constants.NumberOfMeters][]; public Int32[][] GetLineCounterEmptyPipeTest() { return (Int32[][])LineCounterEmptyPipeTest; } public void SetLineCounterEmptyPipeTest(Int32 value, UInt16 meterNumber, UInt16 path) { if (meterNumber < Constants.NumberOfMeters) LineCounterEmptyPipeTest[meterNumber][path] = value; } private Int32[][] LineCounterThermoEmptyPipeTest = new Int32[Constants.NumberOfMeters][]; public Int32[][] GetLineCounterThermoEmptyPipeTest() { return (Int32[][])LineCounterThermoEmptyPipeTest; } public void SetLineCounterThermoEmptyPipeTest(Int32 value, UInt16 meterNumber, UInt16 path) { if (meterNumber < Constants.NumberOfMeters) LineCounterThermoEmptyPipeTest[meterNumber][path] = value; } private Int32[][] LineCounterTemperatureTest = new Int32[Constants.NumberOfThermometers][]; public Int32[][] GetLineCounterTemperatureTest() { return (Int32[][])LineCounterTemperatureTest; } public void SetLineCounterTemperatureTest(Int32 value, UInt16 meterNumber, UInt16 path) { if (meterNumber < Constants.NumberOfMeters) LineCounterTemperatureTest[meterNumber][path] = value; } MeterBatch GlobalMeterBatch = new MeterBatch(); MeterBatch ThermoMeterBatch = new MeterBatch(); private Boolean abortIndicator = false; public Boolean AbortIndicator { get { return abortIndicator; } set { abortIndicator = value; } } public Boolean[] PreparationFailed { get; private set; } private Boolean[] EmptyPipeCheckEnable; public Boolean[] EmptyPipeCheckFailed { get; private set; } private Boolean[] StabilizationEnable; public Boolean[] StabilizationFailed { get; private set; } public Boolean[] LoginFailed { get; private set; } public Boolean[] ThermoLoginFailed { get; private set; } public Boolean[] AmplitudeEnable { get; private set; } public Boolean[] AmplitudeFailed { get; private set; } public Boolean[] CompletionEnable { get; private set; } public Boolean[] ZeroFlowOffsetEnable { get; private set; } public Boolean[] ZeroFlowOffsetFailed { get; private set; } public Boolean[] TempCalEnable { get; private set; } public Boolean[] TempCalFailed { get; private set; } public Boolean[] CompletionFailed { get; private set; } private Boolean WaitForTemperatureField = false; public void SetWaitForTemperatureField(Boolean value) { WaitForTemperatureField = value; } public Boolean[] SerialPortOpenFlag = new Boolean[2 * Constants.NumberOfMeters]; public Boolean[] ThermoSerialPortOpenFlag = new Boolean[2 * Constants.NumberOfThermometers]; #endregion #region Register read back private Int32[][] ToFTempOffset = new Int32[Constants.NumberOfMeters][]; public Int32[][] GetToFTempOffset() { return (Int32[][])ToFTempOffset.Clone(); } public void SetToFTempOffset(UInt16 meterNumber, UInt16 path, Int32 data) { ToFTempOffset[meterNumber][path] = data; } private Int32[][] ZeroFlowOffset = new Int32[Constants.NumberOfMeters][]; public Int32[][] GetZeroFlowOffset() { return (Int32[][])ZeroFlowOffset.Clone(); } public void SetZeroFlowOffset(UInt16 meterNumber, UInt16 path, Int32 data) { ZeroFlowOffset[meterNumber][path] = data; } private Byte[][] FirstHitPercentage = new Byte[Constants.NumberOfMeters][]; public Byte[][] GetFirstHitPercentage() { return (Byte[][])FirstHitPercentage.Clone(); } public void SetFirstHitPercentage(UInt16 meterNumber, UInt16 path, Byte data) { FirstHitPercentage[meterNumber][path] = data; } private UInt16[][] CalFactor = new UInt16[Constants.NumberOfMeters][]; public void SetCalFactor(UInt16 meterNumber, UInt16 path, UInt16 data) { CalFactor[meterNumber][path] = data; } public UInt16[][] GetCalFactor() { return (UInt16[][])CalFactor.Clone(); } #endregion #region Decoded data parameters #region >>>> Central exchange object <<<< // ****** The most important object ****** // *************************************** private CalibrationRecord[][] DecodedAllMeters = new CalibrationRecord[Constants.NumberOfMeters][]; private CalibrationRecord[][] DecodedAllThermometers = new CalibrationRecord[Constants.NumberOfThermometers][]; public CalibrationRecord[][] GetDecodedAllMeters() { return (CalibrationRecord[][])DecodedAllMeters.Clone(); } public CalibrationRecord[][] GetDecodedAllThermometers() { return (CalibrationRecord[][])DecodedAllThermometers.Clone(); } // *************************************** // *************************************** #endregion #endregion #region Serial port parameters private List[] RxStringCmd = new List[Constants.NumberOfMeters]; private String[] RxDataBuffer = new String[Constants.NumberOfMeters]; #endregion #region Initializations public GenesisZeroFlow() { #region Initialize component InitializeComponent(); _GenesisZeroFlow = this; #endregion #region Initialize serial data list for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++) RxStringCmd[Meter] = new List(); #endregion } #endregion // #region Control elements public static GenesisZeroFlow _GenesisZeroFlow; //public static PreAdjustmentControl PreAdjustmentControl = new PreAdjustmentControl(); private void Form1_FormOpening(Object sender, EventArgs e) { // tab_ZeroFlowCal.Controls.Add(PreAdjustmentControl); Display.AbortButtonEnabled(false); InitTemperatures(); CultureInfo Culture = GetGlobalCulture(); CommandInterface1.Initialize(Constants.Meter, Constants.Meter1, Culture); CommandInterface2.Initialize(Constants.Meter, Constants.Meter2, Culture); CommandInterface3.Initialize(Constants.Meter, Constants.Meter3, Culture); CommandInterface4.Initialize(Constants.Meter, Constants.Meter4, Culture); CommandInterface5.Initialize(Constants.Meter, Constants.Meter5, Culture); CommandInterface6.Initialize(Constants.Meter, Constants.Meter6, Culture); CommandInterface7.Initialize(Constants.Meter, Constants.Meter7, Culture); CommandInterface8.Initialize(Constants.Meter, Constants.Meter8, Culture); CommandInterface9.Initialize(Constants.Meter, Constants.Meter9, Culture); CommandInterface10.Initialize(Constants.Meter, Constants.Meter10, Culture); for (UInt16 Flag = 0; Flag < (SerialPortOpenFlag.Count()); Flag++) SerialPortOpenFlag[Flag] = false; for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++) { DecodedAllMeters[Meter] = new CalibrationRecord[Constants.NumberOfPaths]; totalTimeOfFlightAverage[Meter] = new List[Constants.NumberOfPaths]; DeltaTimeOfFlightAverageRAW[Meter] = new List[Constants.NumberOfPaths]; DeltaTimeOfFlightAverage[Meter] = new List[Constants.NumberOfPaths]; AmplitudeValuesUp[Meter] = new List[Constants.NumberOfPaths]; AmplitudeValuesDown[Meter] = new List[Constants.NumberOfPaths]; BadDataCounterZeroFlowTest[Meter] = new Int32[Constants.NumberOfPaths]; LineCounterZeroFlowTest[Meter] = new Int32[Constants.NumberOfPaths]; LineCounterAmplitudeTest[Meter] = new Int32[Constants.NumberOfPaths]; LineCounterEmptyPipeTest[Meter] = new Int32[Constants.NumberOfPaths]; ToFTempOffset[Meter] = new Int32[Constants.NumberOfPaths]; ZeroFlowOffset[Meter] = new Int32[Constants.NumberOfPaths]; FirstHitPercentage[Meter] = new Byte[Constants.NumberOfPaths]; CalFactor[Meter] = new UInt16[Constants.NumberOfPaths]; LoggingPathZeroFlowTest[Meter] = String.Empty; StartLoggingIndicatorAmplitudeTest[Meter] = false; LoggingIndicatorAmpTest[Meter] = false; AmpValuesToLog[Meter] = new String[Constants.NumberOfPaths]; } for (UInt16 Thermo = 0; Thermo < Constants.NumberOfThermometers; Thermo++) { MeasuredTemps[Thermo] = new Double[Constants.NumberOfPaths]; MeasuredTempsIndicator[Thermo] = new Boolean[Constants.NumberOfPaths]; DecodedAllThermometers[Thermo] = new CalibrationRecord[Constants.NumberOfPaths]; NewDataIndicatorTemperatureTest[Thermo] = new Boolean[Constants.NumberOfPaths]; LineCounterTemperatureTest[Thermo] = new Int32[Constants.NumberOfPaths]; LineCounterThermoEmptyPipeTest[Thermo] = new Int32[Constants.NumberOfPaths]; } for (UInt16 Thermo = 0; Thermo < Constants.NumberOfThermometers; Thermo++) { for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++) { MeasuredTemps[Thermo][Path] = new Double(); MeasuredTempsIndicator[Thermo][Path] = new Boolean(); DecodedAllThermometers[Thermo][Path] = new CalibrationRecord(); NewDataIndicatorTemperatureTest[Thermo][Path] = new Boolean(); LineCounterTemperatureTest[Thermo][Path] = new Int32(); LineCounterThermoEmptyPipeTest[Thermo][Path] = new Int32(); } } for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++) { for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++) { totalTimeOfFlightAverage[Meter][Path] = new List(); DeltaTimeOfFlightAverage[Meter][Path] = new List(); DeltaTimeOfFlightAverageRAW[Meter][Path] = new List(); AmplitudeValuesUp[Meter][Path] = new List(); AmplitudeValuesDown[Meter][Path] = new List(); BadDataCounterZeroFlowTest[Meter][Path] = new Int32(); LineCounterZeroFlowTest[Meter][Path] = new Int32(); LineCounterAmplitudeTest[Meter][Path] = new Int32(); LineCounterEmptyPipeTest[Meter][Path] = new Int32(); ToFTempOffset[Meter][Path] = new Int32(); ZeroFlowOffset[Meter][Path] = new Int32(); FirstHitPercentage[Meter][Path] = new Byte(); DecodedAllMeters[Meter][Path] = new CalibrationRecord(); CalFactor[Meter][Path] = new UInt16(); } } #region Set initial images pB_Meter1.Image = pB_Meter1.InitialImage; pB_Meter2.Image = pB_Meter2.InitialImage; pB_Meter3.Image = pB_Meter3.InitialImage; pB_Meter4.Image = pB_Meter4.InitialImage; pB_Meter5.Image = pB_Meter5.InitialImage; pB_Meter6.Image = pB_Meter6.InitialImage; pB_Meter7.Image = pB_Meter7.InitialImage; pB_Meter8.Image = pB_Meter8.InitialImage; pB_Meter9.Image = pB_Meter9.InitialImage; pB_Meter10.Image = pB_Meter10.InitialImage; #endregion #region Set default culture CultureInfo.DefaultThreadCurrentCulture = GetGlobalCulture(); CultureInfo.DefaultThreadCurrentUICulture = GetGlobalCulture(); #endregion #region Get date rTB_ReportEnterDate.Text = DateTime.Now.ToString(Formats.ReportDateTimeTitleString, GetGlobalCulture()); #endregion #region Set default tab //tab_Maintab.TabPages.Remove(tab_Report); tab_Maintab.SelectedTab = tab_ZeroFlowCal; #endregion #region Tooltips #region Definitions and initializations ToolTip ToolTip1 = new ToolTip(); #endregion #region Tool tip settings ToolTip1.AutoPopDelay = 5000; ToolTip1.InitialDelay = 100; ToolTip1.ReshowDelay = 500; ToolTip1.ShowAlways = true; #endregion #region Tool tip implementation #region Form1 Tool tips ToolTip1.SetToolTip(this.pB_Logo1, "www.sensus.com"); #endregion #region Settings tool tips ToolTip1.SetToolTip(this.btn_ZeroFlowCal_Start, "Start sequence"); ToolTip1.SetToolTip(this.tB_PasswordMeter1, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot."); ToolTip1.SetToolTip(this.tB_PasswordMeter2, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot."); ToolTip1.SetToolTip(this.tB_PasswordMeter3, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot."); ToolTip1.SetToolTip(this.tB_PasswordMeter4, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot."); ToolTip1.SetToolTip(this.tB_PasswordMeter5, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot."); ToolTip1.SetToolTip(this.tB_PasswordMeter6, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot."); ToolTip1.SetToolTip(this.tB_PasswordMeter7, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot."); ToolTip1.SetToolTip(this.tB_PasswordMeter8, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot."); ToolTip1.SetToolTip(this.tB_PasswordMeter9, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot."); ToolTip1.SetToolTip(this.tB_PasswordMeter10, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot."); ToolTip1.SetToolTip(this.nUD_Settings_AmplitudeTestLowerLimit, "Lower limit for calculated optimal point"); ToolTip1.SetToolTip(this.nUD_Settings_AmplitudeTestUpperLimit, "Upper limit for calculated optimal point"); ToolTip1.SetToolTip(this.nUD_PercentageStart, "Start value for percentage register sweep"); ToolTip1.SetToolTip(this.nUD_PercentageStop, "Stop value for percentage register sweep"); #endregion #endregion #endregion #region Application settings Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.RealTime; System.Runtime.GCSettings.LatencyMode = System.Runtime.GCLatencyMode.SustainedLowLatency; //System.Runtime.GCSettings.LatencyMode = System.Runtime.GCLatencyMode.LowLatency; //StartUpDisable = false; // to suppress checked change event of check boxes for switching between single and mass logging during start up #endregion if (CultureInfo.InstalledUICulture.Equals(CultureDe)) { lbLanguage.SelectedIndex = 0; Display.SetControlText(CultureDe); } else if (CultureInfo.InstalledUICulture.Equals(CultureEn)) { lbLanguage.SelectedIndex = 1; Display.SetControlText(CultureEn); } var nlogFile = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Genesis", ProgramConfig.NlogConfig); var dir = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Genesis"); if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } if (!File.Exists(nlogFile)) { var fileCop = ProgramConfig.NlogConfig; try { System.IO.File.Copy(fileCop, nlogFile); } catch (Exception) { MessageBox.Show("Logfiles not created, call developer"); } } var configfile = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Genesis", ProgramConfig.SerialConfigFileName); if (!File.Exists(configfile)) { MessageBox.Show("No Configuration, please do setup"); var setupWindow = new FrmSetup(); setupWindow.ShowDialog(); } } private void Form1_FormClosing(Object sender, FormClosingEventArgs e) { #region Definitions and initializations CultureInfo Culture = GetGlobalCulture(); DateTime time = new DateTime(); time = DateTime.Now; String TimeForHeader = time.ToString(Formats.RawDataDateTimeLogString, Culture); String TimeForFilename = time.ToString(Formats.LogFileDateTimeString, Culture); String Username = System.Security.Principal.WindowsIdentity.GetCurrent().Name; String ClosingPath = $"{DataLogging.DefaultPath}ZeroflowCalibrationTool_EventLogging_{TimeForFilename}.txt"; String Header = $"Filename = {Path.GetFileName(ClosingPath)}; User = {Username}; Date/Time = {TimeForHeader}\n"; String Data = rTB_ZeroFlowCal.Text; #endregion #region Logfile Logging.WriteToFile($"{Header}{Data}", ClosingPath); #endregion Environment.Exit(0); } private void btn_ZeroFlowCal_Detect_Click(object sender, EventArgs e) { CultureInfo Culture = GetGlobalCulture(); if (cB_SinglePath.Checked) Constants.NumberOfPaths = 1; else Constants.NumberOfPaths = 3; try { btn_ZeroFlowCal_Detect.Enabled = false; if (GlobalMeterBatch.ListOfMeters.Any()) GlobalMeterBatch.RemoveAllMeters(); if (ThermoMeterBatch.ListOfMeters.Any()) ThermoMeterBatch.RemoveAllMeters(); GlobalMeterBatch = new MeterBatch(); ThermoMeterBatch = new MeterBatch(); #region Definitions and initializations if (cB_ZeroFlowCal_EnableMeter1.Checked) GlobalMeterBatch.AddMeter(new ZeroFlowGenesisMeter(Constants.Slot1)); if (cB_ZeroFlowCal_EnableMeter2.Checked) GlobalMeterBatch.AddMeter(new ZeroFlowGenesisMeter(Constants.Slot2)); if (cB_ZeroFlowCal_EnableMeter3.Checked) GlobalMeterBatch.AddMeter(new ZeroFlowGenesisMeter(Constants.Slot3)); if (cB_ZeroFlowCal_EnableMeter4.Checked) GlobalMeterBatch.AddMeter(new ZeroFlowGenesisMeter(Constants.Slot4)); if (cB_ZeroFlowCal_EnableMeter5.Checked) GlobalMeterBatch.AddMeter(new ZeroFlowGenesisMeter(Constants.Slot5)); if (cB_ZeroFlowCal_EnableMeter6.Checked) GlobalMeterBatch.AddMeter(new ZeroFlowGenesisMeter(Constants.Slot6)); if (cB_ZeroFlowCal_EnableMeter7.Checked) GlobalMeterBatch.AddMeter(new ZeroFlowGenesisMeter(Constants.Slot7)); if (cB_ZeroFlowCal_EnableMeter8.Checked) GlobalMeterBatch.AddMeter(new ZeroFlowGenesisMeter(Constants.Slot8)); if (cB_ZeroFlowCal_EnableMeter9.Checked) GlobalMeterBatch.AddMeter(new ZeroFlowGenesisMeter(Constants.Slot9)); if (cB_ZeroFlowCal_EnableMeter10.Checked) GlobalMeterBatch.AddMeter(new ZeroFlowGenesisMeter(Constants.Slot10)); #region Thermometer if (cB_Thermo1.Checked) ThermoMeterBatch.AddMeter(new ZeroFlowGenesisMeter(Constants.Slot11)); // Thermometer if (cB_Thermo2.Checked) ThermoMeterBatch.AddMeter(new ZeroFlowGenesisMeter(Constants.Slot12)); // Thermometer #endregion foreach (var generalMeter in GlobalMeterBatch.ListOfMeters) { if (generalMeter is ZeroFlowGenesisMeter) { var Meter = generalMeter as ZeroFlowGenesisMeter; Meter.LogOnEnable = SerialPortOpenFlag[Meter.Slot - 1] & SerialPortOpenFlag[(Meter.Slot - 1) + Constants.NumberOfMeters]; Meter.LoginFailed = false; Meter.PreparationFailed = false; Meter.AmplitudeFailed = false; Meter.ZeroFlowOffsetFailed = false; Meter.AmplitudeFailed = false; Meter.CompletionFailed = false; Meter.Ok = false; Meter.EmptyPipeCheckEnable = false; Meter.EmptyPipeCheckFailed = false; } } foreach (var generalMeter in ThermoMeterBatch.ListOfMeters) { if (generalMeter is ZeroFlowGenesisMeter) { var Meter = generalMeter as ZeroFlowGenesisMeter; Meter.LogOnEnable = ThermoSerialPortOpenFlag[Meter.Slot - 11] & ThermoSerialPortOpenFlag[(Meter.Slot - 11) + Constants.NumberOfThermometers]; Meter.LoginFailed = false; Meter.PreparationFailed = false; Meter.AmplitudeFailed = false; Meter.ZeroFlowOffsetFailed = false; Meter.AmplitudeFailed = false; Meter.CompletionFailed = false; Meter.Ok = false; Meter.EmptyPipeCheckEnable = false; Meter.EmptyPipeCheckFailed = false; } } #endregion Misc.WaitNSeconds(2, true); btn_ZeroFlowCal_Detect.Enabled = true; } catch (Exception ex) { MessageBox.Show(PredefinedMessages.DetectFailed(Culture)); btn_ZeroFlowCal_Detect.Enabled = true; return; } #region Definitions and initializations Boolean[] EnableOpening = new Boolean[Constants.NumberOfMeters]; Boolean[] ThermoEnableOpening = new Boolean[Constants.NumberOfThermometers]; Boolean[] Ok = new Boolean[2 * Constants.NumberOfMeters]; Boolean[] ThermoOk = new Boolean[2 * Constants.NumberOfThermometers]; Boolean[] SetToUnknownStatus = new Boolean[Constants.NumberOfMeters]; Boolean[] ThermoSetToUnknownStatus = new Boolean[Constants.NumberOfThermometers]; EnableOpening[Constants.Meter1] = cB_ZeroFlowCal_EnableMeter1.Checked; EnableOpening[Constants.Meter2] = cB_ZeroFlowCal_EnableMeter2.Checked; EnableOpening[Constants.Meter3] = cB_ZeroFlowCal_EnableMeter3.Checked; EnableOpening[Constants.Meter4] = cB_ZeroFlowCal_EnableMeter4.Checked; EnableOpening[Constants.Meter5] = cB_ZeroFlowCal_EnableMeter5.Checked; EnableOpening[Constants.Meter6] = cB_ZeroFlowCal_EnableMeter6.Checked; EnableOpening[Constants.Meter7] = cB_ZeroFlowCal_EnableMeter7.Checked; EnableOpening[Constants.Meter8] = cB_ZeroFlowCal_EnableMeter8.Checked; EnableOpening[Constants.Meter9] = cB_ZeroFlowCal_EnableMeter9.Checked; EnableOpening[Constants.Meter10] = cB_ZeroFlowCal_EnableMeter10.Checked; ThermoEnableOpening[Constants.Thermo1] = cB_Thermo1.Checked; ThermoEnableOpening[Constants.Thermo2] = cB_Thermo2.Checked; btn_ZeroFlowCal_Start.Enabled = false; AbortIndicator = false; #endregion #region Bubbles pB_Bubbles1.Visible = true; #endregion if (LogOnSequences.CheckIfNoMeterSelected(EnableOpening)) { MessageBox.Show(PredefinedMessages.NoMeterSelected(Culture), "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error); Display.StatusLabel(PredefinedMessages.PressDetect(Culture)); Display.SetControlElements(true); return; } SetToUnknownStatus[Constants.Meter1] = !cB_ZeroFlowCal_EnableMeter1.Checked; SetToUnknownStatus[Constants.Meter2] = !cB_ZeroFlowCal_EnableMeter2.Checked; SetToUnknownStatus[Constants.Meter3] = !cB_ZeroFlowCal_EnableMeter3.Checked; SetToUnknownStatus[Constants.Meter4] = !cB_ZeroFlowCal_EnableMeter4.Checked; SetToUnknownStatus[Constants.Meter5] = !cB_ZeroFlowCal_EnableMeter5.Checked; SetToUnknownStatus[Constants.Meter6] = !cB_ZeroFlowCal_EnableMeter6.Checked; SetToUnknownStatus[Constants.Meter7] = !cB_ZeroFlowCal_EnableMeter7.Checked; SetToUnknownStatus[Constants.Meter8] = !cB_ZeroFlowCal_EnableMeter8.Checked; SetToUnknownStatus[Constants.Meter9] = !cB_ZeroFlowCal_EnableMeter9.Checked; SetToUnknownStatus[Constants.Meter10] = !cB_ZeroFlowCal_EnableMeter10.Checked; ThermoSetToUnknownStatus[Constants.Thermo1] = !cB_Thermo1.Checked; ThermoSetToUnknownStatus[Constants.Thermo2] = !cB_Thermo2.Checked; #region Visual indication 'PREPARE' Display.SetProgressPanel(StatusPanelItems.Detect); Display.StatusLabel(PredefinedMessages.WaitDetect(Culture)); foreach (var generalMeter in GlobalMeterBatch.ListOfMeters) { if (generalMeter is ZeroFlowGenesisMeter) { var Meter = generalMeter as ZeroFlowGenesisMeter; Ok[(Meter.Slot - 1)] = Meter.CheckRequestPort(); Ok[(Meter.Slot - 1) + Constants.NumberOfMeters] = Meter.CheckStreamingPort(); } } foreach (var generalMeter in ThermoMeterBatch.ListOfMeters) { if (generalMeter is ZeroFlowGenesisMeter) { var Thermometer = generalMeter as ZeroFlowGenesisMeter; ThermoOk[(Thermometer.Slot - 11)] = Thermometer.CheckRequestPort(); ThermoOk[(Thermometer.Slot - 11) + Constants.NumberOfThermometers] = Thermometer.CheckStreamingPort(); } } Display.ConnectionStatus(Ok); Display.ThermoConnectionStatus(ThermoOk); SerialPortOpenFlag = Ok; ThermoSerialPortOpenFlag = ThermoOk; Display.ConnectionStatusReset(SetToUnknownStatus); Display.ThermoConnectionStatusReset(ThermoSetToUnknownStatus); #endregion #region Status message Display.StatusLabel(PredefinedMessages.PressStartOrDetect(Culture)); btn_ZeroFlowCal_Start.Enabled = true; pB_Bubbles1.Visible = false; #endregion } private ProcessProgress Login(ProcessProgress pp) { Display.PictureBoxVisble(pB_Bubbles1, true); Display.StatusLabel( PredefinedMessages.WaitUntilLoginFinished(pp.Culture)); // "Wait until 'LOGIN' has finished" Display.DebugMessage($"{Constants.TwentySpaces}\tCOMMAND CHANNEL: \t LOGIN procedure started\n", pp.Culture); pp.MeterOk = new Boolean[Constants.NumberOfMeters]; pp.ThermoOk = new Boolean[Constants.NumberOfThermometers]; pp.AllOk = new Boolean[Constants.NumberOfMeters + Constants.NumberOfThermometers]; LoginFailed = new Boolean[Constants.NumberOfMeters]; for (UInt16 i = 0; i < LoginFailed.Count(); i++) LoginFailed[i] = false; ThermoLoginFailed = new Boolean[Constants.NumberOfThermometers]; for (UInt16 i = 0; i < ThermoLoginFailed.Count(); i++) ThermoLoginFailed[i] = false; var listOfLoginTask = new List(); var listOfMeterFromSource = new Dictionary(); foreach (var meter in GlobalMeterBatch.ListOfMeters) { listOfMeterFromSource.Add(meter, false); } foreach (var meter in ThermoMeterBatch.ListOfMeters) { listOfMeterFromSource.Add(meter, true); } foreach (var meterAndBatch in listOfMeterFromSource) { var meter = meterAndBatch.Key; var isThermo = meterAndBatch.Value; listOfLoginTask.Add(Task.Run(() => { var Result = false; for (int i = 0; i < 3; i++) { Display.DebugMessage($"{Constants.TwentySpaces}\tCOMMAND CHANNEL: \t Performing LOGIN procedure\n", pp.Culture); try { Result = string.IsNullOrEmpty(pp.Passwords[meter.Slot - 1]) ? meter.Login() : meter.Login(pp.Passwords[meter.Slot - 1]); if (Result) { return Result; } Thread.Sleep(100); } catch (Exception e) { Display.DebugMessage($"{Constants.TwentySpaces}\tCOMMAND CHANNEL: \t Error on LOGIN procedure\n", pp.Culture); } } return Result; }, pp.CancellationSource.Token).ContinueWith(delegate (Task loginTask) { var taskResultSlot = loginTask.Result; var meterIndex = (meter.Slot).ToString(pp.Culture); if (taskResultSlot) { Display.DebugMessage( $"{Constants.TwentySpaces}\tCOMMAND CHANNEL: \t LOGIN procedure successful at METER{meterIndex}\n", pp.Culture); if (isThermo) { ThermoLoginFailed[meter.Slot - 1] = false; pp.AtLeastOneThermometerPresent = true; } else { LoginFailed[meter.Slot - 1] = false; pp.AtLeastOneMeterPresent = true; } } else { Display.DebugMessage( $"{Constants.TwentySpaces}\tCOMMAND CHANNEL: \t LOGIN procedure failed at METER{meterIndex}\n", pp.Culture); if (isThermo) { ThermoLoginFailed[meter.Slot - 1] = true; } else { LoginFailed[meter.Slot - 1] = true; } GenerateReturnNote($"{meterIndex}", PcbID[meter.Slot - 1], PredefinedMessages.LoginFailed(pp.Culture), _GenesisZeroFlow.GetLoggingFromTextBox(), pp.Culture); } }, pp.CancellationSource.Token)); } return Task.WhenAll(listOfLoginTask).ContinueWith(delegate { var loginFailed = LoginFailed; var thermoLoginFailed = ThermoLoginFailed; var meterEnable = pp.MeterEnable; var thermoEnable = pp.ThermoEnable; pp.AllOk = Display.GetSequenceResult(meterEnable.Concat(thermoEnable).ToArray(), loginFailed.Concat(thermoLoginFailed).ToArray(), "LOGIN sequence", out pp.StopSequence, pp.Culture); pp.MeterOk = Misc.Subarray(pp.AllOk, 0, Constants.NumberOfMeters); pp.ThermoOk = Misc.Subarray(pp.AllOk, Constants.NumberOfMeters, Constants.NumberOfThermometers); Display.MeterStatusGreenRed(pp.MeterOk, meterEnable); Display.ThermoStatusGreenRed(pp.ThermoOk, thermoEnable); if (pp.StopSequence) { StopMainSequence(PredefinedMessages.LoginFailed(pp.Culture), MessageBoxIcon.Error, pp.Culture); } AbortIndicator = false; Display.SetControlElements(false); Display.SetProgressPanel(StatusPanelItems.Prepare); if ((!GlobalMeterBatch.ListOfMeters.Any())) { StopMainSequence(PredefinedMessages.NoMeterSelected(pp.Culture), MessageBoxIcon.Error, pp.Culture); } if ((pp.AtLeastOneThermometerPresent) || (pp.AtLeastOneMeterPresent)) return pp; StopMainSequence( !pp.AtLeastOneThermometerPresent ? PredefinedMessages.NoThermometerPresent(pp.Culture) : PredefinedMessages.NoMeterPresent(pp.Culture), MessageBoxIcon.Error, pp.Culture); return pp; }, pp.CancellationSource.Token).Result; } private ProcessProgress PrepareTest(ProcessProgress pp) { #region Definitions and initializations #region Temperature monitoring limits pp.UpperTempLimit = GetUpperTempLimit(); pp.LowerTempLimit = GetLowerTempLimit(); pp.TempDeviationLimit = GetTempDeviationLimit(); pp.StopSequence = false; pp.Aborted = false; pp.AtLeastOneThermometerPresent = false; pp.AtLeastOneMeterPresent = false; pp.MeterEnable = new Boolean[Constants.NumberOfMeters]; pp.ThermoEnable = new Boolean[Constants.NumberOfThermometers]; for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++) { pp.MeterEnable[Meter] = false; PcbID[Meter] = String.Empty; } for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++) { pp.ThermoEnable[Thermo] = false; ThermoID[Thermo] = String.Empty; } #endregion #region Passwords pp.Passwords = new String[Constants.NumberOfMeters]; pp.Passwords[Constants.Meter1] = tB_PasswordMeter1.Text; pp.Passwords[Constants.Meter2] = tB_PasswordMeter2.Text; pp.Passwords[Constants.Meter3] = tB_PasswordMeter3.Text; pp.Passwords[Constants.Meter4] = tB_PasswordMeter4.Text; pp.Passwords[Constants.Meter5] = tB_PasswordMeter5.Text; pp.Passwords[Constants.Meter6] = tB_PasswordMeter6.Text; pp.Passwords[Constants.Meter7] = tB_PasswordMeter7.Text; pp.Passwords[Constants.Meter8] = tB_PasswordMeter8.Text; pp.Passwords[Constants.Meter9] = tB_PasswordMeter9.Text; pp.Passwords[Constants.Meter10] = tB_PasswordMeter10.Text; pp.ThermoPasswords = new String[Constants.NumberOfThermometers]; pp.ThermoPasswords[Constants.Thermo1] = tB_PasswordThermo1.Text; pp.ThermoPasswords[Constants.Thermo2] = tB_PasswordThermo2.Text; CultureInfo Culture = GetGlobalCulture(); #endregion #endregion #region Get enable status foreach (var meter in GlobalMeterBatch.ListOfMeters) pp.MeterEnable[meter.Slot - 1] = true; foreach (var meter in ThermoMeterBatch.ListOfMeters) pp.ThermoEnable[meter.Slot - 11] = true; #endregion return pp; } private ProcessProgress Preparation(ProcessProgress pp) { if (Equals(_GenesisZeroFlow.AbortIndicator, false)) { var listOfPcdIdTask = new List(); var listOfMeterFromSource = new List(); foreach (var meter in GlobalMeterBatch.ListOfMeters) { listOfMeterFromSource.Add(meter); } foreach (var meter in ThermoMeterBatch.ListOfMeters) { listOfMeterFromSource.Add(meter); } foreach (var item in listOfMeterFromSource) { if (!(item is ZeroFlowGenesisMeter)) continue; var meter = (ZeroFlowGenesisMeter)item; if (!pp.MeterEnable[meter.Slot - 1]) continue; listOfPcdIdTask.Add(Task.Run(() => { var tmp = meter.PcbId; if (string.IsNullOrEmpty(tmp)) PcbID[meter.Slot - 1] = "ID is not available "; else { var numberOfSpaces = 20 - tmp.Length; if (numberOfSpaces > 0) { for (var i = 0; i < numberOfSpaces; i++) tmp = $"{tmp} "; } PcbID[meter.Slot - 1] = tmp; } Display.DebugMessage($"{Constants.TwentySpaces}\tCOMMAND CHANNEL:\t PCB ID = {tmp}\n", pp.Culture); })); } Task.WhenAll(listOfPcdIdTask); Display.StatusLabel(PredefinedMessages.WaitUntilPreparationFinished(pp.Culture)); // "Wait until 'PREPARATION' finished #region add com port listener foreach (var item in GlobalMeterBatch.ListOfMeters) { if (!(item is ZeroFlowGenesisMeter)) continue; ((ZeroFlowGenesisMeter)item).OnZeroFlowRecordIsDecoded += GenesisZeroFlow_OnZeroFlowRecordIsDecoded; ((ZeroFlowGenesisMeter)item).StartRecordData(); } foreach (var item in ThermoMeterBatch.ListOfMeters) { if (!(item is ZeroFlowGenesisMeter)) continue; ((ZeroFlowGenesisMeter)item).OnZeroFlowRecordIsDecoded += GenesisZeroFlow_OnThermoRecordIsDecoded; ((ZeroFlowGenesisMeter)item).StartRecordData(); } #endregion PreparationFailed = PreparationSequences.Total(GlobalMeterBatch, ThermoMeterBatch, (UInt16)nUD_SettingsPreparationMetersize.Value, cB_ZeroFlowOffsetTestEnable.Checked, pp.UpperTempLimit, pp.LowerTempLimit, pp.TempDeviationLimit, out pp.Aborted, pp.Culture); pp.AllOk = Display.GetSequenceResult(pp.MeterEnable.Concat(pp.ThermoEnable).ToArray(), PreparationFailed, "PREPARATION sequence", out pp.StopSequence, pp.Culture); pp.MeterOk = Misc.Subarray(pp.AllOk, 0, Constants.NumberOfMeters); pp.ThermoOk = Misc.Subarray(pp.AllOk, Constants.NumberOfMeters, Constants.NumberOfThermometers); Display.MeterStatusGreenRed(pp.MeterOk, pp.MeterEnable); Display.ThermoStatusGreenRed(pp.ThermoOk, pp.ThermoEnable); if (pp.StopSequence) { StopMainSequence(PredefinedMessages.ZeroflowCalibrationSequenceFailed(pp.Culture), MessageBoxIcon.Error, pp.Culture); return pp; } #region Empty pipe mode check Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t EMPTY PIPE CHECK sequence started\n", pp.Culture); EmptyPipeCheckEnable = pp.AllOk; EmptyPipeCheckFailed = EmptyPipeCheckSequences.Total(EmptyPipeCheckEnable, out pp.Aborted, GlobalMeterBatch, ThermoMeterBatch, pp.Culture); pp.MeterEnable = Misc.Subarray(EmptyPipeCheckEnable, 0, Constants.NumberOfMeters); pp.ThermoEnable = Misc.Subarray(EmptyPipeCheckEnable, Constants.NumberOfMeters, Constants.NumberOfThermometers); pp.AllOk = Display.GetSequenceResult(EmptyPipeCheckEnable, EmptyPipeCheckFailed, "EMPTY PIPE CHECK sequence", out pp.StopSequence, pp.Culture); Display.MeterStatusGreenRed(Misc.Subarray(pp.AllOk, 0, Constants.NumberOfMeters), pp.MeterEnable); Display.ThermoStatusGreenRed(Misc.Subarray(pp.AllOk, Constants.NumberOfMeters, Constants.NumberOfThermometers), pp.ThermoEnable); if (pp.StopSequence) { StopMainSequence(PredefinedMessages.ZeroflowCalibrationSequenceFailed(pp.Culture), MessageBoxIcon.Error, pp.Culture); return pp; } #endregion #region Wait for two minutes StabilizationEnable = pp.AllOk; Display.WaitForStabilization(StabilizationEnable, (Int32)nUD_Settings_Preparation_StabiTime.Value, out pp.Aborted, pp.Culture); StabilizationFailed = EmptyPipeCheckFailed; // WaitForStabilization does not have return value; pp.MeterEnable = Misc.Subarray(StabilizationEnable, 0, Constants.NumberOfMeters); pp.ThermoEnable = Misc.Subarray(StabilizationEnable, Constants.NumberOfMeters, Constants.NumberOfThermometers); pp.AllOk = Display.GetSequenceResult(StabilizationEnable, StabilizationFailed, "WAIT FOR STABILIZATION sequence", out pp.StopSequence, pp.Culture); Display.MeterStatusGreenRed(Misc.Subarray(pp.AllOk, 0, Constants.NumberOfMeters), pp.MeterEnable); Display.ThermoStatusGreenRed(Misc.Subarray(pp.AllOk, Constants.NumberOfMeters, Constants.NumberOfThermometers), pp.ThermoEnable); if (pp.StopSequence) { StopMainSequence(PredefinedMessages.ZeroflowCalibrationSequenceFailed(pp.Culture), MessageBoxIcon.Error, pp.Culture); return pp; } #endregion } else { Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t PREPARATION sequence stopped\n", pp.Culture); Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", pp.Culture); StopMainSequence(PredefinedMessages.ZeroflowCalibrationSequenceStopped(pp.Culture), MessageBoxIcon.Error, pp.Culture); } return pp; } private ProcessProgress AmplitudeTest(ProcessProgress pp) { if (!cB_AmplitudeTestEnable.Checked) return pp; Display.StatusLabel(PredefinedMessages.WaitUntilAmplitudeTestFinished(pp.Culture)); if (_GenesisZeroFlow.AbortIndicator) { StopMainSequence(PredefinedMessages.ZeroflowCalibrationSequenceStopped(pp.Culture), MessageBoxIcon.Error, pp.Culture); return pp; } AmplitudeEnable = pp.AllOk; Display.SetProgressPanel(StatusPanelItems.Amplitude); Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t AMPLITUDE TEST sequence started\n", pp.Culture); Display.StatusLabel( PredefinedMessages .WaitUntilAmplitudeFinished(pp.Culture)); // "Wait until AMPLITUDE TEST has finished" AmplitudeFailed = AmplitudeSequences.Total(GlobalMeterBatch, ThermoMeterBatch, AmplitudeEnable, (Int32)nUD_PercentageStart.Value, (Int32)nUD_PercentageStop.Value, (Int32)nUD_Settings_AmplitudeTestLowerLimit.Value, (Int32)nUD_Settings_AmplitudeTestUpperLimit.Value, (Int32)nUD_Settings_AmplitudeTestMinDistance.Value, pp.UpperTempLimit, pp.LowerTempLimit, pp.TempDeviationLimit, out pp.Aborted, pp.Culture); pp.MeterEnable = Misc.Subarray(AmplitudeEnable, 0, Constants.NumberOfMeters); pp.ThermoEnable = Misc.Subarray(AmplitudeEnable, Constants.NumberOfMeters, Constants.NumberOfThermometers); pp.AllOk = Display.GetSequenceResult(AmplitudeEnable, AmplitudeFailed, "AMPLITUDE sequence", out pp.StopSequence, pp.Culture); Display.MeterStatusGreenRed(Misc.Subarray(pp.AllOk, 0, Constants.NumberOfMeters), pp.MeterEnable); Display.ThermoStatusGreenRed( Misc.Subarray(pp.AllOk, Constants.NumberOfMeters, Constants.NumberOfThermometers), pp.ThermoEnable); if (!pp.StopSequence) return pp; StopMainSequence(PredefinedMessages.ZeroflowCalibrationSequenceFailed(pp.Culture), MessageBoxIcon.Error, pp.Culture); return pp; } private ProcessProgress OffsetTest(ProcessProgress pp) { if (!cB_ZeroFlowOffsetTestEnable.Checked) return pp; if (_GenesisZeroFlow.AbortIndicator) { StopMainSequence(PredefinedMessages.ZeroflowCalibrationSequenceStopped(pp.Culture), MessageBoxIcon.Error, pp.Culture); return pp; } ZeroFlowOffsetEnable = pp.AllOk; Display.SetProgressPanel(StatusPanelItems.Offset); Display.DebugMessage( $"{Constants.TwentySpaces}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST sequence started\n", pp.Culture); Display.StatusLabel( PredefinedMessages .WaitUntilZeroflowOffsetTestFinished( pp.Culture)); ZeroFlowOffsetFailed = ZeroOffsetSequences.Total(GlobalMeterBatch, ThermoMeterBatch, ZeroFlowOffsetEnable, (Int16)nUD_Settings_ZeroflowOffsetTestSettlingTime.Value, (Int16)nUD_Settings_ZeroflowOffsetTestLowerLimit.Value, (Int16)nUD_Settings_ZeroflowOffsetTestUpperLimit.Value, (Double)nUD_Settings_ZeroflowOffsetTestOffsetLimit.Value, (Int32)nUD_Settings_ZeroflowOffsetTestNumberOfLines.Value, pp.UpperTempLimit, pp.LowerTempLimit, pp.TempDeviationLimit, out pp.Aborted, pp.Culture); pp.MeterEnable = Misc.Subarray(ZeroFlowOffsetEnable, 0, Constants.NumberOfMeters); pp.ThermoEnable = Misc.Subarray(ZeroFlowOffsetEnable, Constants.NumberOfMeters, Constants.NumberOfThermometers); pp.AllOk = Display.GetSequenceResult(ZeroFlowOffsetEnable, ZeroFlowOffsetFailed, "ZEROFLOW OFFSET TEST sequence", out pp.StopSequence, pp.Culture); Display.MeterStatusGreenRed(Misc.Subarray(pp.AllOk, 0, Constants.NumberOfMeters), pp.MeterEnable); Display.ThermoStatusGreenRed( Misc.Subarray(pp.AllOk, Constants.NumberOfMeters, Constants.NumberOfThermometers), pp.ThermoEnable); if (pp.StopSequence) { StopMainSequence(PredefinedMessages.ZeroflowCalibrationSequenceFailed(pp.Culture), MessageBoxIcon.Error, pp.Culture); return pp; } return pp; } private ProcessProgress TemperatureCalibration(ProcessProgress pp) { if (!cB_TempCalEnable.Checked) return pp; Display.SetProgressPanel(StatusPanelItems.TempCal); Display.StatusLabel(PredefinedMessages.WaitUntilTemperatureAcquisitionFinished(pp.Culture)); TempCalEnable = pp.AllOk; var manAcquisition = cB_TempManualAcquisition.Checked || (!cB_Thermo1.Checked) && (!cB_Thermo2.Checked); TempCalFailed = TempCalibrationSequences.Total(GlobalMeterBatch, ThermoMeterBatch, TempCalEnable, manAcquisition, pp.UpperTempLimit, pp.LowerTempLimit, pp.TempDeviationLimit, out pp.Aborted, pp.Culture); pp.MeterEnable = Misc.Subarray(TempCalEnable, 0, Constants.NumberOfMeters); // width of TempCalEnable = 8bit, Temperature Monitoring not needed pp.ThermoEnable = Misc.Subarray(TempCalEnable, Constants.NumberOfMeters, Constants.NumberOfThermometers); pp.AllOk = Display.GetSequenceResult(TempCalEnable, TempCalFailed, "TEMPERATURE CALIBRATION sequence", out pp.StopSequence, pp.Culture); Display.MeterStatusGreenRed(Misc.Subarray(pp.AllOk, 0, Constants.NumberOfMeters), pp.MeterEnable); Display.ThermoStatusGreenRed( Misc.Subarray(pp.AllOk, Constants.NumberOfMeters, Constants.NumberOfThermometers), pp.ThermoEnable); if (pp.StopSequence) { StopMainSequence(PredefinedMessages.ZeroflowCalibrationSequenceFailed(pp.Culture), MessageBoxIcon.Error, pp.Culture); return pp; } return pp; } private ProcessProgress Completion(ProcessProgress pp) { Display.SetThermoLabel1("THERMO1"); Display.SetThermoLabel2("THERMO2"); if (_GenesisZeroFlow.AbortIndicator) { StopMainSequence(PredefinedMessages.ZeroflowCalibrationSequenceStopped(pp.Culture), MessageBoxIcon.Error, pp.Culture); return pp; } CompletionEnable = pp.AllOk; Display.SetProgressPanel(StatusPanelItems.Completion); Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t COMPLETION sequence started\n", pp.Culture); Display.StatusLabel( PredefinedMessages.WaitUntilCompletionFinished(pp.Culture)); // "Wait until 'COMPLETION' has finished" pp.MeterEnable = Misc.Subarray(CompletionEnable, 0, Constants.NumberOfMeters); // width of TempCalEnable = 8bit, Temperature Monitoring not needed pp.ThermoEnable = Misc.Subarray(CompletionEnable, Constants.NumberOfMeters, Constants.NumberOfThermometers); CompletionFailed = CompletionSequences.Total(GlobalMeterBatch, ThermoMeterBatch, CompletionEnable, out pp.Aborted, pp.Culture); pp.AllOk = Display.GetSequenceResult(CompletionEnable, CompletionFailed, "COMPLETION sequence", out pp.StopSequence, pp.Culture); Display.MeterStatusGreenRed(Misc.Subarray(pp.AllOk, 0, Constants.NumberOfMeters), pp.MeterEnable); Display.ThermoStatusGreenRed( Misc.Subarray(pp.AllOk, Constants.NumberOfMeters, Constants.NumberOfThermometers), pp.ThermoEnable); if (pp.Aborted) { StopMainSequence(PredefinedMessages.ZeroflowCalibrationSequenceStopped(pp.Culture), MessageBoxIcon.Error, pp.Culture); return pp; } if (pp.StopSequence) { StopMainSequence(PredefinedMessages.ZeroflowCalibrationSequenceFailed(pp.Culture), MessageBoxIcon.Error, pp.Culture); return pp; } Display.DebugMessage( $"{Constants.TwentySpaces}\tAPPLICATION:\t\t ZEROFLOW CALIBRATION sequence successful\n", pp.Culture); Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", pp.Culture); StopMainSequence(PredefinedMessages.ZeroflowCalibrationSequenceSuccessful(pp.Culture), MessageBoxIcon.Information, pp.Culture); GlobalMeterBatch.RemoveAllMeters(); ThermoMeterBatch.RemoveAllMeters(); return pp; } private void btn_ZeroFlowCal_Start_Click(object sender, EventArgs e) { try { ZeroflowOffsetTestNumberOfLines = (Int32)nUD_Settings_ZeroflowOffsetTestNumberOfLines.Value; rTB_ZeroFlowCal.Clear(); // Clear log (textbox) var currentProgress = new ProcessProgress(); OnAbort += (o, args) => currentProgress.CancellationSource.Cancel(); List> listOfProgrammParts = new List>(); listOfProgrammParts.Add(new Task(() => { return PrepareTest(currentProgress); })); listOfProgrammParts.Add(new Task(() => { return Login(currentProgress); })); listOfProgrammParts.Add(new Task(() => { return Preparation(currentProgress); })); listOfProgrammParts.Add(new Task(() => { return AmplitudeTest(currentProgress); })); listOfProgrammParts.Add(new Task(() => { return TemperatureCalibration(currentProgress); })); listOfProgrammParts.Add(new Task(() => { return OffsetTest(currentProgress); })); listOfProgrammParts.Add(new Task(() => { return Completion(currentProgress); })); Task.Run(() => { foreach (var cTask in listOfProgrammParts) { cTask.Start(); currentProgress = cTask.Result; AfterStep(currentProgress); } } ); } catch (Exception exception) { Display.DebugMessage($"Exception at full process: { exception.Message}\t{Debugmessages.Line}", CultureDe); Display.DebugMessage(exception.StackTrace, CultureDe); } } private void AfterStep(ProcessProgress pp) { checkMetersToRemove(pp); } private void checkMetersToRemove(ProcessProgress pp) { //todo remove meter that are failed //foreach (var meter in GlobalMeterBatch.ListOfMeters) //{ // if (pp.MeterEnable.Length >= meter.Slot) // { // if (!pp.MeterEnable[meter.Slot - 1]) // { // GlobalMeterBatch.RemoveMeter(meter); // } // } // if (pp.MeterOk.Length >= meter.Slot) // { // if (!pp.MeterOk[meter.Slot - 1]) // { // GlobalMeterBatch.RemoveMeter(meter); // } // } //} } public event EventHandler OnAbort; private void btn_ZeroFlowCal_Abort_Click(object sender, EventArgs e) { CultureInfo Culture = GetGlobalCulture(); DialogResult AskForActions = DialogResult.None; Display.AbortButtonEnabled(false); AskForActions = MessageBox.Show(PredefinedMessages.AreYouSure(Culture), "Form closing", MessageBoxButtons.OKCancel, MessageBoxIcon.Error); if (DialogResult.Equals(AskForActions, DialogResult.OK)) { AbortIndicator = true; OnAbort?.Invoke(this, EventArgs.Empty); } else { AbortIndicator = false; Display.AbortButtonEnabled(true); } } private void btn_ZeroFlowCal_Clear_Click(object sender, EventArgs e) { #region Bubbles pB_Bubbles1.Visible = true; Misc.WaitNSeconds(1, true); pB_Bubbles1.Visible = false; #endregion rTB_ZeroFlowCal.Clear(); } private void btn_ZeroFlowCal_Save_Click(object sender, EventArgs e) { #region Definitions and initializations CultureInfo Culture = GetGlobalCulture(); String SaveDataPathRaw = String.Empty; Boolean RawDialogOk = false; String Username = System.Security.Principal.WindowsIdentity.GetCurrent().Name; String ClosingPath = DataLogging.DefaultPath;// + "GenesisZeroFlow_EventLogging_" + TimeForFilename + ".txt"; String TimeForHeader = String.Empty; #endregion #region Bubbles pB_Bubbles1.Visible = true; Misc.WaitNSeconds(1, true); pB_Bubbles1.Visible = false; #endregion #region Logfile try { RawDialogOk = Files.SaveFiledialogTxt(out SaveDataPathRaw, ClosingPath, out TimeForHeader, Culture); if (RawDialogOk) { String Data = rTB_ZeroFlowCal.Text; String Header = $"Filename = {Path.GetFileName(SaveDataPathRaw)}; User = {Username}; Date/Time = {TimeForHeader}; SW-version: {l_Version.Text}\n"; Logging.WriteToFile($"{Header}{Data}", SaveDataPathRaw); } } catch (Exception ex) { ErrorLog.Log(LogErrReason.Exeption, "btn_ZeroFlowCal_Save_Click() failed", $"0x{ex.HResult.ToString("X", Culture)}", String.Empty, Culture); MessageBox.Show(PredefinedMessages.StorageFailed(Culture), "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error); } #endregion } private void btn_ZeroFlowCal_Pdf_Click(object sender, EventArgs e) { #region Definitions and initializations String SaveDataPathPdf = String.Empty; Boolean RawDialogOk = false; String Username = System.Security.Principal.WindowsIdentity.GetCurrent().Name; String ClosingPath = DataLogging.DefaultPath; String TimeForHeader = String.Empty; CultureInfo Culture = GetGlobalCulture(); #endregion #region Bubbles pB_Bubbles1.Visible = true; Misc.WaitNSeconds(1, true); pB_Bubbles1.Visible = false; #endregion #region Logfile try { RawDialogOk = Files.SaveFiledialogPdf(out SaveDataPathPdf, ClosingPath, out TimeForHeader, Culture); if (RawDialogOk) { //using (PdfDocument LogReport = new PdfDocument()) //{ // LogReport.Info.Title = "GENESIS Zeroflow calibration tool logfile"; // LogReport.Info.Author = Username; // String Data = rTB_ZeroFlowCal.Text; // String Header = $"Filename = {Path.GetFileName(SaveDataPathPdf)};\nUser = {Username};\nDate/Time = {TimeForHeader}\nSW-version: {l_Version.Text}\n\n"; // ReportPages.Logfile($"{ Header}{ Data}", LogReport, Logo); // //Files.SavePdf(LogReport, SaveDataPathPdf, Culture); //} } } catch (Exception ex) { ErrorLog.Log(LogErrReason.Exeption, "btn_ZeroFlowCal_Pdf_Click() failed", $"0x{ex.HResult.ToString("X", Culture)}", String.Empty, Culture); MessageBox.Show(PredefinedMessages.StorageFailed(Culture), "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error); } } #endregion public void EnableMaintab() { tab_Maintab.Enabled = true; } public List[] GetAmplitudeValuesUp(UInt16 meterNumber) { return AmplitudeValuesUp[meterNumber]; } public void ClearAmplitudeValuesUp(UInt16 meterNumber) { if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired) { GenesisZeroFlow._GenesisZeroFlow.Invoke((Action)ClearAmplitudeValuesUp, meterNumber); return; } for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++) AmplitudeValuesUp[meterNumber][Path].Clear(); } public void ClearAmplitudeValuesDown(UInt16 meterNumber) { if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired) { GenesisZeroFlow._GenesisZeroFlow.Invoke((Action)ClearAmplitudeValuesDown, meterNumber); return; } for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++) AmplitudeValuesDown[meterNumber][Path].Clear(); } public List[] GetAmplitudeValuesDown(UInt16 meterNumber) { return AmplitudeValuesDown[meterNumber]; } public void ClearBadDataCounter(UInt16 meterNumber) { if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired) { GenesisZeroFlow._GenesisZeroFlow.Invoke((Action)ClearBadDataCounter, meterNumber); return; } for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++) BadDataCounterZeroFlowTest[meterNumber][Path] = 0; } public Int32[] GetBadDataCounter(UInt16 meterNumber) { return BadDataCounterZeroFlowTest[meterNumber]; } public void ClearLineCounterZeroFlow(UInt16 meterNumber) { if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired) { GenesisZeroFlow._GenesisZeroFlow.Invoke((Action)ClearLineCounterZeroFlow, meterNumber); return; } for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++) SetLineCounterZeroFlowTest(meterNumber, Path, 0); } public Int32[] GetLineCounterZeroFlow(UInt16 meterNumber) { return LineCounterZeroFlowTest[meterNumber]; } public void ClearDeltaTimeOfFlightAverage(UInt16 meterNumber) { if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired) { GenesisZeroFlow._GenesisZeroFlow.Invoke((Action)ClearDeltaTimeOfFlightAverage, meterNumber); return; } for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++) { DeltaTimeOfFlightAverage[meterNumber][Path].Clear(); DeltaTimeOfFlightAverageRAW[meterNumber][Path].Clear(); } } public List[] GetDeltaTimeOfFlightAverageRaw(UInt16 meterNumber) { return DeltaTimeOfFlightAverageRAW[meterNumber]; } public List[] GetDeltaTimeOfFlightAverage(UInt16 meterNumber) { return DeltaTimeOfFlightAverage[meterNumber]; } public Boolean GetCBMeanAmplitudeFiles() { return (Boolean)cB_MeanAmplitudeFiles.Checked; } public Boolean GetCBAmpLogFiles() { return (Boolean)cB_AmpLogFiles.Checked; } public Boolean GetCBOffsetTestLogFiles() { return (Boolean)cB_OffsetTestLogFiles.Checked; } public Int32 GetAmplitudeActivityCheckInterval() { return (Int32)(nUD_Settings_AmplitudeActivityCheckInterval.Value); } public Int32 GetZeroFlowActivityCheckInterval() { return (Int32)(nUD_Settings_ZeroflowOffsetTestActivityCheckInterval.Value); } private Int32 ZeroflowOffsetTestNumberOfLines = 9000; private void GenesisZeroFlow_OnZeroFlowRecordIsDecoded(object sender, CalibrationRecordWithMeterNumber decodedDataAndMeterNr) { //CultureInfo Culture = GetGlobalCulture(); var decodedDate = decodedDataAndMeterNr; var MeterNumber = decodedDataAndMeterNr.MeterNumber; var data = ((CalibrationRecord)decodedDate.CalibChl); //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 (GetLoggingIndicatorZeroFlowTest()[MeterNumber] && (!String.IsNullOrEmpty(LoggingPathZeroFlowTest[MeterNumber]))) { try { String time = DateTime.Now.ToString(Formats.RawDataDateTimeLogString); SetDataToLog(MeterNumber, $"{GetDataToLog()[MeterNumber]} {time} {decodedDate.RawData}\n"); } catch (Exception ex) { } } if (GetLoggingIndicatorAmpTest()[MeterNumber] && (!String.IsNullOrEmpty(LoggingPathAmplitudeTest[MeterNumber]))) { try { String time = DateTime.Now.ToString(Formats.RawDataDateTimeLogString); var tmp = GetDataToLog()[MeterNumber]; String StringToLog = $"{tmp} {time} {decodedDate.RawData}\n"; SetDataToLog(MeterNumber, StringToLog); } catch (Exception ex) { } } #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 LineCounterEmptyPipeTest[MeterNumber][Path] = Counters.SetCounters(LoggingIndicatorEmptyPipeTest, MeterNumber, Path, ref LineCounterEmptyPipeTest); #endregion #region Data for amplitude test if (GetTofIndicatorAmplitudeTest()[MeterNumber]) { totalTimeOfFlightAverage[MeterNumber][Path].Add(TotalTimeOfFlightS); } LineCounterAmplitudeTest[MeterNumber][Path] = Counters.SetCounters(LoggingIndicatorAmpTest, MeterNumber, Path, ref LineCounterAmplitudeTest); #endregion #region Data for zero flow test var meterDone = true; foreach (var checkCompleted in LineCounterZeroFlowTest[MeterNumber]) { if (checkCompleted < ZeroflowOffsetTestNumberOfLines) { meterDone = false; } } if (meterDone) { SetCalculationIndicatorZeroFlowTest(false, MeterNumber); SetLoggingIndicatorZeroFlowTest(false, MeterNumber); } var CalcIndicator = GetCalculationIndicatorZeroFlowTest()[MeterNumber]; if (CalcIndicator) { #region Bad data check if (decodedDate.CalibChl.Validation == DataError.NoError) { AmplitudeValuesUp[MeterNumber][Path].Add(decodedDate.CalibChl.AmplitudeUpV); AmplitudeValuesDown[MeterNumber][Path].Add(decodedDate.CalibChl.AmplitudeDownV); DeltaTimeOfFlightAverageRAW[MeterNumber][Path].Add(decodedDate.CalibChl.RAWDeltaTimeOfFlight); DeltaTimeOfFlightAverage[MeterNumber][Path].Add(decodedDate.CalibChl.DeltaTimeOfFlightS); LineCounterZeroFlowTest[MeterNumber][Path] = Counters.SetCounters(GetCalculationIndicatorZeroFlowTest(), MeterNumber, Path, ref LineCounterZeroFlowTest); } else { BadDataCounterZeroFlowTest[MeterNumber][Path] = Counters.SetCounters(GetCalculationIndicatorZeroFlowTest(), MeterNumber, Path, ref BadDataCounterZeroFlowTest); } #endregion } #endregion //#region Activity check for temperature test //try //{ // LineCounterTemperatureTest[MeterNumber][Path] = Counters.SetCounters(IndicatorTemperatureActivityCheck, MeterNumber, Path, ref LineCounterTemperatureTest); //} //catch (Exception ex) //{ //} //#endregion } #endregion #region Copy to global object DecodedAllMeters[MeterNumber][Path] = ((CalibrationRecord)decodedDate.CalibChl.Clone()); #endregion } private void GenesisZeroFlow_OnThermoRecordIsDecoded(object sender, CalibrationRecordWithMeterNumber decodedDataAndMeterNr) { CultureInfo Culture = GetGlobalCulture(); var decodedDate = decodedDataAndMeterNr; var ThermoNumber = (UInt16)(decodedDataAndMeterNr.MeterNumber - 10); var data = ((CalibrationRecord)decodedDate.CalibChl); //todo make new imesturementrecord according to units need by zeroflow app var TotalTimeOfFlightS = data.TotalTimeOfFlightS * 1000000; var CalcTemperature = data.TemperatureDegC; Double temp = data.DeltaTimeOfFlightS; //data.DeltaTimeOfFlightS = data.DeltaTimeOfFlightS * (1.0 / 0x4000000000); // 2^38; //todo check performance -> into ram Int32 numberOfLines = (Int32)nUD_Settings_ZeroflowOffsetTestNumberOfLines.Value; #region Logging (Zero flow test) //if (GetLoggingIndicatorTemperatureTest()[ThermoNumber] && (!String.IsNullOrEmpty(LoggingPathTemperatureTest[ThermoNumber]))) //{ // String time = DateTime.Now.ToString(Formats.RawDataDateTimeLogString, Culture); // SetTemperatureToLog(ThermoNumber, $"{GetDataToLog()[ThermoNumber]} {time} {decodedDate}\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 LineCounterThermoEmptyPipeTest[ThermoNumber][Path] = Counters.SetCounters(LoggingIndicatorThermoEmptyPipeTest, ThermoNumber, Path, ref LineCounterThermoEmptyPipeTest); #endregion if (IndicatorTemperatureActivityCheck[ThermoNumber]) { GenesisZeroFlow._GenesisZeroFlow.SetTemperatures(ThermoNumber, Path, CalcTemperature); NewDataIndicatorTemperatureTest[ThermoNumber][Path] = true; #region Activity check for temperature test LineCounterTemperatureTest[ThermoNumber][Path] = Counters.SetCounters(IndicatorTemperatureActivityCheck, ThermoNumber, Path, ref LineCounterTemperatureTest); #endregion } } #endregion #region Copy to global object DecodedAllThermometers[ThermoNumber][Path] = ((CalibrationRecord)decodedDate.CalibChl.Clone()); #endregion } private void button1_Click(object sender, EventArgs e) { MessageBox.Show(CultureInfo.InstalledUICulture.ToString() + "Index = " + lbLanguage.SelectedIndex.ToString()); //GenesisZeroFlow.ActiveForm.PerformAutoScale(); } private void lbLanguage_Click(object sender, EventArgs e) { lbLanguage.Enabled = false; CultureInfo Culture = GetGlobalCulture(); Misc.WaitNSeconds(1, true); Display.SetControlText(Culture); lbLanguage.Enabled = true; } private void BtnOpenSetup_Click(object sender, EventArgs e) { var setupWindow = new FrmSetup(); setupWindow.ShowDialog(); } //todo check for reimplementation private void GenesisZeroFlow_Resize(object sender, EventArgs e) { // int Width_small = 85; // int Width_big = 150; // Screen screen = Screen.FromControl(this); // int ScreenWidth = screen.Bounds.Width; // int ScreenHeight = screen.Bounds.Height; // const int gap = 6; // const int width = 90; // const int bigwidth = 130; // Point Marking1 = new Point(12,78); // Point Marking2 = new Point(30, 78); // Point ImagePos1 = new Point(18, 18); // Point ImagePos2 = new Point(40, 18); // Point MeterPos1 = new Point(18, 102); // Point MeterPos2 = new Point(170, 150); // Point GB_ProgressPos1 = new Point (6, 342); // Point GB_ProgressPos2 = new Point(170, 480); // Point GB_StatusPos1 = new Point(24, 294); // Point GB_StatusPos2 = new Point(180, 400); // Point TextBoxPosition1 = new Point(14, 570); // Point TextBoxPosition2 = new Point(14, 700); // const int CheckBoxY = 150; // const int CheckBoxGap = 12; // const int TextBoxHeight1 = 90; // const int TextBoxHeight2 = 280; // if (this.WindowState == FormWindowState.Normal) // { // p_ZeroFlowCal_Meter1.Width = Width_small; // rTB_ZeroFlowCal.Height = TextBoxHeight1; // //this.Hide(); // l_ZeroFlowCal_Status.Location = GB_StatusPos1; // gB_Meters.Width = 906; // p_ZeroFlowCal_Meter1.Width = 85; // p_ZeroFlowCal_Meter2.Width = 85; // p_ZeroFlowCal_Meter3.Width = 85; // p_ZeroFlowCal_Meter4.Width = 85; // p_ZeroFlowCal_Meter5.Width = 85; // p_ZeroFlowCal_Meter6.Width = 85; // p_ZeroFlowCal_Meter7.Width = 85; // p_ZeroFlowCal_Meter8.Width = 85; // p_ZeroFlowCal_Meter9.Width = 85; // p_ZeroFlowCal_Meter10.Width = 85; // p_ZeroFlowCal_Meter1.Location = new Point(gap, 12); // p_ZeroFlowCal_Meter2.Location = new Point(width + gap, 12); // p_ZeroFlowCal_Meter3.Location = new Point(2*width+gap, 12); // p_ZeroFlowCal_Meter4.Location = new Point(3*width+gap, 12); // p_ZeroFlowCal_Meter5.Location = new Point(4*width+gap, 12); // p_ZeroFlowCal_Meter6.Location = new Point(5*width+gap, 12); // p_ZeroFlowCal_Meter7.Location = new Point(6*width+gap, 12); // p_ZeroFlowCal_Meter8.Location = new Point(7*width+gap, 12); // p_ZeroFlowCal_Meter9.Location = new Point(8*width+gap, 12); // p_ZeroFlowCal_Meter10.Location = new Point(9*width+gap, 12); // l_ZeroFlowCal_Meter1.Location = Marking1; // l_ZeroFlowCal_Meter2.Location = Marking1; // l_ZeroFlowCal_Meter3.Location = Marking1; // l_ZeroFlowCal_Meter4.Location = Marking1; // l_ZeroFlowCal_Meter5.Location = Marking1; // l_ZeroFlowCal_Meter6.Location = Marking1; // l_ZeroFlowCal_Meter7.Location = Marking1; // l_ZeroFlowCal_Meter8.Location = Marking1; // l_ZeroFlowCal_Meter9.Location = Marking1; // l_ZeroFlowCal_Meter10.Location = Marking1; // pB_Meter1.Location = ImagePos1; // pB_Meter2.Location = ImagePos1; // pB_Meter3.Location = ImagePos1; // pB_Meter4.Location = ImagePos1; // pB_Meter5.Location = ImagePos1; // pB_Meter6.Location = ImagePos1; // pB_Meter7.Location = ImagePos1; // pB_Meter8.Location = ImagePos1; // pB_Meter9.Location = ImagePos1; // pB_Meter10.Location = ImagePos1; // cB_ZeroFlowCal_EnableMeter1.Location = new Point(CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter2.Location = new Point(width + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter3.Location = new Point(2*width + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter4.Location = new Point(3*width + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter5.Location = new Point(4*width + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter6.Location = new Point(5*width + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter7.Location = new Point(6*width + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter8.Location = new Point(7*width + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter9.Location = new Point(8*width + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter10.Location = new Point(9*width + CheckBoxGap, CheckBoxY); // gB_Meters.Location = MeterPos1; // gB_Progress.Location = GB_ProgressPos1; // rTB_ZeroFlowCal.Location = TextBoxPosition1; // } // if (this.WindowState == FormWindowState.Maximized) // { // if (ScreenWidth > 1200) // { // l_ZeroFlowCal_Status.Location = GB_StatusPos2; // p_ZeroFlowCal_Meter1.Width = Width_big; // gB_Meters.Width = 1306; // p_ZeroFlowCal_Meter1.Width = 127; // p_ZeroFlowCal_Meter2.Width = 127; // p_ZeroFlowCal_Meter3.Width = 127; // p_ZeroFlowCal_Meter4.Width = 127; // p_ZeroFlowCal_Meter5.Width = 127; // p_ZeroFlowCal_Meter6.Width = 127; // p_ZeroFlowCal_Meter7.Width = 127; // p_ZeroFlowCal_Meter8.Width = 127; // p_ZeroFlowCal_Meter9.Width = 127; // p_ZeroFlowCal_Meter10.Width = 127; // p_ZeroFlowCal_Meter1.Location = new Point(gap, 12); // p_ZeroFlowCal_Meter2.Location = new Point(bigwidth + gap, 12); // p_ZeroFlowCal_Meter3.Location = new Point(2 * bigwidth + gap, 12); // p_ZeroFlowCal_Meter4.Location = new Point(3 * bigwidth + gap, 12); // p_ZeroFlowCal_Meter5.Location = new Point(4 * bigwidth + gap, 12); // p_ZeroFlowCal_Meter6.Location = new Point(5 * bigwidth + gap, 12); // p_ZeroFlowCal_Meter7.Location = new Point(6 * bigwidth + gap, 12); // p_ZeroFlowCal_Meter8.Location = new Point(7 * bigwidth + gap, 12); // p_ZeroFlowCal_Meter9.Location = new Point(8 * bigwidth + gap, 12); // p_ZeroFlowCal_Meter10.Location = new Point(9 * bigwidth + gap, 12); // l_ZeroFlowCal_Meter1.Location = Marking2; // l_ZeroFlowCal_Meter2.Location = Marking2; // l_ZeroFlowCal_Meter3.Location = Marking2; // l_ZeroFlowCal_Meter4.Location = Marking2; // l_ZeroFlowCal_Meter5.Location = Marking2; // l_ZeroFlowCal_Meter6.Location = Marking2; // l_ZeroFlowCal_Meter7.Location = Marking2; // l_ZeroFlowCal_Meter8.Location = Marking2; // l_ZeroFlowCal_Meter9.Location = Marking2; // l_ZeroFlowCal_Meter10.Location = Marking2; // cB_ZeroFlowCal_EnableMeter1.Location = new Point(CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter2.Location = new Point(bigwidth + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter3.Location = new Point(2 * bigwidth + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter4.Location = new Point(3 * bigwidth + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter5.Location = new Point(4 * bigwidth + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter6.Location = new Point(5 * bigwidth + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter7.Location = new Point(6 * bigwidth + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter8.Location = new Point(7 * bigwidth + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter9.Location = new Point(8 * bigwidth + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter10.Location = new Point(9 * bigwidth + CheckBoxGap, CheckBoxY); // gB_Meters.Location = MeterPos2; // gB_Progress.Location = GB_ProgressPos2; // rTB_ZeroFlowCal.Height = TextBoxHeight2; // rTB_ZeroFlowCal.Location = TextBoxPosition2; // //pB_Meter1.Location = ImagePos2; // pB_Meter2.Location = ImagePos2; // pB_Meter3.Location = ImagePos2; // pB_Meter4.Location = ImagePos2; // pB_Meter5.Location = ImagePos2; // pB_Meter6.Location = ImagePos2; // pB_Meter7.Location = ImagePos2; // pB_Meter8.Location = ImagePos2; // pB_Meter9.Location = ImagePos2; // pB_Meter10.Location = ImagePos2; // } // else // { // l_ZeroFlowCal_Status.Location = GB_StatusPos1; // p_ZeroFlowCal_Meter1.Width = Width_small; // gB_Meters.Width = 906; // p_ZeroFlowCal_Meter1.Width = 85; // p_ZeroFlowCal_Meter2.Width = 85; // p_ZeroFlowCal_Meter3.Width = 85; // p_ZeroFlowCal_Meter4.Width = 85; // p_ZeroFlowCal_Meter5.Width = 85; // p_ZeroFlowCal_Meter6.Width = 85; // p_ZeroFlowCal_Meter7.Width = 85; // p_ZeroFlowCal_Meter8.Width = 85; // p_ZeroFlowCal_Meter9.Width = 85; // p_ZeroFlowCal_Meter10.Width = 85; // p_ZeroFlowCal_Meter1.Location = new Point(gap, 12); // p_ZeroFlowCal_Meter2.Location = new Point(width + gap, 12); // p_ZeroFlowCal_Meter3.Location = new Point(2 * width + gap, 12); // p_ZeroFlowCal_Meter4.Location = new Point(3 * width + gap, 12); // p_ZeroFlowCal_Meter5.Location = new Point(4 * width + gap, 12); // p_ZeroFlowCal_Meter6.Location = new Point(5 * width + gap, 12); // p_ZeroFlowCal_Meter7.Location = new Point(6 * width + gap, 12); // p_ZeroFlowCal_Meter8.Location = new Point(7 * width + gap, 12); // p_ZeroFlowCal_Meter9.Location = new Point(8 * width + gap, 12); // p_ZeroFlowCal_Meter10.Location = new Point(9 * width + gap, 12); // l_ZeroFlowCal_Meter1.Location = Marking1; // l_ZeroFlowCal_Meter2.Location = Marking1; // l_ZeroFlowCal_Meter3.Location = Marking1; // l_ZeroFlowCal_Meter4.Location = Marking1; // l_ZeroFlowCal_Meter5.Location = Marking1; // l_ZeroFlowCal_Meter6.Location = Marking1; // l_ZeroFlowCal_Meter7.Location = Marking1; // l_ZeroFlowCal_Meter8.Location = Marking1; // l_ZeroFlowCal_Meter9.Location = Marking1; // l_ZeroFlowCal_Meter10.Location = Marking1; // pB_Meter1.Location = ImagePos1; // pB_Meter2.Location = ImagePos1; // pB_Meter3.Location = ImagePos1; // pB_Meter4.Location = ImagePos1; // pB_Meter5.Location = ImagePos1; // pB_Meter6.Location = ImagePos1; // pB_Meter7.Location = ImagePos1; // pB_Meter8.Location = ImagePos1; // pB_Meter9.Location = ImagePos1; // pB_Meter10.Location = ImagePos1; // cB_ZeroFlowCal_EnableMeter1.Location = new Point(CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter2.Location = new Point(width + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter3.Location = new Point(2 * width + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter4.Location = new Point(3 * width + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter5.Location = new Point(4 * width + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter6.Location = new Point(5 * width + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter7.Location = new Point(6 * width + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter8.Location = new Point(7 * width + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter9.Location = new Point(8 * width + CheckBoxGap, CheckBoxY); // cB_ZeroFlowCal_EnableMeter10.Location = new Point(9 * width + CheckBoxGap, CheckBoxY); // gB_Meters.Location = MeterPos1; // gB_Progress.Location = GB_ProgressPos1; // rTB_ZeroFlowCal.Height = TextBoxHeight1; // rTB_ZeroFlowCal.Location = TextBoxPosition1; // } //this.Hide(); // } } } }