marekf/common
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
master
common/Ui/GenesisZeroFlow/MainWindows.cs

1106 lines
54 KiB
C#
Raw Permalink Normal View History

Initial commit
2026-04-23 15:50:07 +00:00
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Globalization;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Net;
using System.Drawing.Printing;
using System.Diagnostics;
using System.Media;
using System.IO;
using System.Text.RegularExpressions;
using Ui.GenesisZeroFlow;
namespace Ui.GenesisZeroFlow
{
public partial class MainWindows : Form
{
#region Global parameters
private List<double>[][] AmplitudeValuesPositive = new List<double>[Constants.Core.NumberOfMeters][];
private List<double>[][] AmplitudeValuesNegative { get; set; } = new List<double>[Constants.Core.NumberOfMeters][];
public List<double>[][] TotalTimeOfFlightAverage { get; set; } = new List<double>[Constants.Core.NumberOfMeters][];
private List<double>[][] DeltaTimeOfFlightAverage = new List<double>[Constants.Core.NumberOfMeters][];
public string[] DataToLog { get; set; } = new string[Constants.Core.NumberOfMeters];
public string[][] NumbersToLog = new string[Constants.Core.NumberOfMeters][];
public bool[][] NewDataFlagZeroFlowTest = new bool[Constants.Core.NumberOfMeters][];
public bool[] LoggingFlagZeroFlowTest = new bool[Constants.Core.NumberOfMeters];
public bool[] CalculationFlagZeroFlowTest = new bool[Constants.Core.NumberOfMeters];
public string[] LoggingPathZeroFlowTest = new string[Constants.Core.NumberOfMeters];
private int[][] BadDataCounterZeroFlowTest = new int[Constants.Core.NumberOfMeters][];
private int[][] LineCounterZeroFlowTest = new int[Constants.Core.NumberOfMeters][];
public bool[][] NewDataFlagAmplitudeTest = new bool[Constants.Core.NumberOfMeters][];
public bool[] StartLoggingFlagAmplitudeTest = new bool[Constants.Core.NumberOfMeters];
public bool[] LoggingFlagAmplitudeTest = new bool[Constants.Core.NumberOfMeters];
public string[] LoggingPathAmplitudeTest = new string[Constants.Core.NumberOfMeters];
public int[][] LineCounterAmplitudeTest = new int[Constants.Core.NumberOfMeters][];
public bool FirstTime = false;
public bool AbortFlag = false;
public bool WaitForTemperatureField = false;
bool[] SerialPortOpenFlag = new bool[20] { false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false };
#endregion
#region register read back
public int[][] ToFTempOffset = new int[Constants.Core.NumberOfMeters][];
public int[][] ZeroFlowOffset = new int[Constants.Core.NumberOfMeters][];
public int[][] FirstHitPercentage = new int[Constants.Core.NumberOfMeters][];
public int[][] CalFactor = new int[Constants.Core.NumberOfMeters][];
#endregion
#region Decoded data parameters
#region Mean values
#endregion
#endregion
#region Serial port parameters
List<byte>[] RxStringCmd = new List<byte>[Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters];
string[] RxStringData = new string[Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters];
#endregion
#region Others
// Declare the PrintDocument object.
// private System.Drawing.Printing.PrintDocument docToPrint =
// new System.Drawing.Printing.PrintDocument();
#endregion
#region Initializations
public GenesisZeroFlow()
{
#region Initialize component
InitializeComponent();
_GenesisZeroFlow = this;
#endregion
#region Initialize serial data list
for (UInt16 Meter = 0; Meter < Constants.Core.NumberOfMeters; Meter++)
RxStringCmd[Meter] = new List<byte>();
#endregion
}
#endregion
// #region Control elements
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2211:NonConstantFieldsShouldNotBeVisible")]
public static GenesisZeroFlow _GenesisZeroFlow;
private void Form1_FormOpening(Object sender, System.EventArgs e)
{
this.rTB_ZeroFlowCal.AutoSize = true;
this.rTB_forDebugging.AutoSize = true;
Display.AbortButtonEnabled(false);
for (int i = 0; i < Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters; i++)
{
NewDataFlagAmplitudeTest[i] = new bool[Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters];
TotalTimeOfFlightAverage[i] = new List<double>[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
DeltaTimeOfFlightAverage[i] = new List<double>[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
NewDataFlagZeroFlowTest[i] = new bool[Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters];
AmplitudeValuesPositive[i] = new List<double>[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
AmplitudeValuesNegative[i] = new List<double>[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
BadDataCounterZeroFlowTest[i] = new int[Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters];
LineCounterZeroFlowTest[i] = new int[Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters];
LineCounterAmplitudeTest[i] = new int[Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters];
ToFTempOffset[i] = new int[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
ZeroFlowOffset[i] = new int[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
FirstHitPercentage[i] = new int[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
CalFactor[i] = new int[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
CalculationFlagZeroFlowTest[i] = false;
LoggingFlagZeroFlowTest[i] = false;
LoggingPathZeroFlowTest[i] = string.Empty;
StartLoggingFlagAmplitudeTest[i] = false;
LoggingFlagAmplitudeTest[i] = false;
NumbersToLog[i] = new string[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
}
for (int i = 0; i < Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters; i++)
{
for (int j = 0; j < Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths; j++)
{
NewDataFlagAmplitudeTest[i][j] = new bool();
TotalTimeOfFlightAverage[i][j] = new List<double>();
DeltaTimeOfFlightAverage[i][j] = new List<double>();
NewDataFlagZeroFlowTest[i][j] = new bool();
AmplitudeValuesPositive[i][j] = new List<double>();
AmplitudeValuesNegative[i][j] = new List<double>();
BadDataCounterZeroFlowTest[i][j] = new int();
LineCounterZeroFlowTest[i][j] = new int();
LineCounterAmplitudeTest[i][j] = new int();
ToFTempOffset[i][j] = new int();
ZeroFlowOffset[i][j] = new int();
FirstHitPercentage[i][j] = new int();
CalFactor[i][j] = new int();
}
}
#region Set initial images
pB_ZeroFlowCal_Meter1.Image = pB_ZeroFlowCal_Meter1.InitialImage;
pB_ZeroFlowCal_Meter2.Image = pB_ZeroFlowCal_Meter2.InitialImage;
pB_ZeroFlowCal_Meter3.Image = pB_ZeroFlowCal_Meter3.InitialImage;
pB_ZeroFlowCal_Meter4.Image = pB_ZeroFlowCal_Meter4.InitialImage;
pB_ZeroFlowCal_Meter5.Image = pB_ZeroFlowCal_Meter5.InitialImage;
pB_ZeroFlowCal_Meter6.Image = pB_ZeroFlowCal_Meter6.InitialImage;
pB_ZeroFlowCal_Meter7.Image = pB_ZeroFlowCal_Meter7.InitialImage;
pB_ZeroFlowCal_Meter8.Image = pB_ZeroFlowCal_Meter8.InitialImage;
pB_ZeroFlowCal_Meter9.Image = pB_ZeroFlowCal_Meter9.InitialImage;
pB_ZeroFlowCal_Meter10.Image = pB_ZeroFlowCal_Meter10.InitialImage;
#endregion
#region Set default culture
CultureInfo culture = CultureInfo.CreateSpecificCulture("en-US");
CultureInfo.DefaultThreadCurrentCulture = culture;
CultureInfo.DefaultThreadCurrentUICulture = culture;
#endregion
#region Get date
rTB_ReportEnterDate.Text = DateTime.Now.ToString(Formats.ReportDateTimeTitleString, culture);
#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.rTB_PasswordMeter1, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
ToolTip1.SetToolTip(this.rTB_PasswordMeter2, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
ToolTip1.SetToolTip(this.rTB_PasswordMeter3, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
ToolTip1.SetToolTip(this.rTB_PasswordMeter4, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
ToolTip1.SetToolTip(this.rTB_PasswordMeter5, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
ToolTip1.SetToolTip(this.rTB_PasswordMeter6, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
ToolTip1.SetToolTip(this.rTB_PasswordMeter7, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
ToolTip1.SetToolTip(this.rTB_PasswordMeter8, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
ToolTip1.SetToolTip(this.rTB_PasswordMeter9, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
ToolTip1.SetToolTip(this.rTB_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
System.Diagnostics.Process.GetCurrentProcess().PriorityClass = System.Diagnostics.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
}
private void Form1_FormClosing(Object sender, FormClosingEventArgs e)
{
#region Definitions and initializations
DateTime time = new DateTime();
time = DateTime.Now;
string TimeForHeader = time.ToString(Formats.RawDataDateTimeLogString, GlobalCulture);
string TimeForFilename = time.ToString(Formats.LogFileDateTimeString, GlobalCulture);
string Username = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
string ClosingPath = DataLogging.DefaultPath + "GenesisZeroFlow_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)
{
#region Definitions and initializations
bool[] EnableOpening = new bool[Constants.Core.NumberOfMeters];
bool[] OK = new bool[2 * Constants.Core.NumberOfMeters];
bool[] SetToUnknownStatus = new bool[Constants.Core.NumberOfMeters];
EnableOpening[Constants.Core.Meter1] = cB_ZeroFlowCal_EnableMeter1.Checked;
EnableOpening[Constants.Core.Meter2] = cB_ZeroFlowCal_EnableMeter2.Checked;
EnableOpening[Constants.Core.Meter3] = cB_ZeroFlowCal_EnableMeter3.Checked;
EnableOpening[Constants.Core.Meter4] = cB_ZeroFlowCal_EnableMeter4.Checked;
EnableOpening[Constants.Core.Meter5] = cB_ZeroFlowCal_EnableMeter5.Checked;
EnableOpening[Constants.Core.Meter6] = cB_ZeroFlowCal_EnableMeter6.Checked;
EnableOpening[Constants.Core.Meter7] = cB_ZeroFlowCal_EnableMeter7.Checked;
EnableOpening[Constants.Core.Meter8] = cB_ZeroFlowCal_EnableMeter8.Checked;
EnableOpening[Constants.Core.Meter9] = cB_ZeroFlowCal_EnableMeter9.Checked;
EnableOpening[Constants.Core.Meter10] = cB_ZeroFlowCal_EnableMeter10.Checked;
btn_ZeroFlowCal_Start.Enabled = false;
Display.DebugCrcIndicatorVisible(false);
AbortFlag = false;
#endregion
#region Bubbles
pB_Bubbles1.Visible = true;
#endregion
if (LoginSequences.CheckIfNoMeterSelected(EnableOpening))
{
MessageBox.Show("No METER selected", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
Display.StatusLabel("Press 'DETECT'");
SetControlElements(true);
return;
}
SetToUnknownStatus[Constants.Core.Meter1] = !cB_ZeroFlowCal_EnableMeter1.Checked;
SetToUnknownStatus[Constants.Core.Meter2] = !cB_ZeroFlowCal_EnableMeter2.Checked;
SetToUnknownStatus[Constants.Core.Meter3] = !cB_ZeroFlowCal_EnableMeter3.Checked;
SetToUnknownStatus[Constants.Core.Meter4] = !cB_ZeroFlowCal_EnableMeter4.Checked;
SetToUnknownStatus[Constants.Core.Meter5] = !cB_ZeroFlowCal_EnableMeter5.Checked;
SetToUnknownStatus[Constants.Core.Meter6] = !cB_ZeroFlowCal_EnableMeter6.Checked;
SetToUnknownStatus[Constants.Core.Meter7] = !cB_ZeroFlowCal_EnableMeter7.Checked;
SetToUnknownStatus[Constants.Core.Meter8] = !cB_ZeroFlowCal_EnableMeter8.Checked;
SetToUnknownStatus[Constants.Core.Meter9] = !cB_ZeroFlowCal_EnableMeter9.Checked;
SetToUnknownStatus[Constants.Core.Meter10] = !cB_ZeroFlowCal_EnableMeter10.Checked;
#region Visual indication 'PREPARE'
string[] ListOfComports = SerialConfigGetReadSettings.PortNames();
Display.SetProgressPanel(StatusPanelItems.Detect);
Display.StatusLabel("Wait until DETECTION has finished");
OK = DetectionSequence(EnableOpening);
Display.ConnectionStatus(OK);
SerialPortOpenFlag = OK;
Display.ConnectionStatusReset(SetToUnknownStatus);
#endregion
Display.StatusLabel("Press 'START' or repeat 'DETECT'");
btn_ZeroFlowCal_Start.Enabled = true;
pB_Bubbles1.Visible = false;
}
private void SetControlElements(bool enabled)
{
if (enabled)
{
pB_Bubbles1.Visible = false;
btn_ZeroFlowCal_Detect.Enabled = true;
cB_ZeroFlowCal_EnableMeter1.Enabled = true;
cB_ZeroFlowCal_EnableMeter2.Enabled = true;
cB_ZeroFlowCal_EnableMeter3.Enabled = true;
cB_ZeroFlowCal_EnableMeter4.Enabled = true;
cB_ZeroFlowCal_EnableMeter5.Enabled = true;
cB_ZeroFlowCal_EnableMeter6.Enabled = true;
cB_ZeroFlowCal_EnableMeter7.Enabled = true;
cB_ZeroFlowCal_EnableMeter8.Enabled = true;
cB_ZeroFlowCal_EnableMeter9.Enabled = true;
cB_ZeroFlowCal_EnableMeter10.Enabled = true;
gB_Settings_AmplitudeTest.Enabled = true;
gB_Settings_ZeroflowOffsetTest.Enabled = true;
gB_Passwords.Enabled = true;
gB_Settings_Preparation.Enabled = true;
gB_Settings_TemperatureCalibration.Enabled = true;
btn_ZeroFlowCal_Pdf.Enabled = true;
btn_ZeroFlowCal_Save.Enabled = true;
btn_ZeroFlowCal_Clear.Enabled = true;
Display.AbortButtonEnabled(false);
cB_AmplitudeTestEnable.Enabled = true;
cB_TempCalEnable.Enabled = true;
cB_ZeroFlowOffsetTestEnable.Enabled = true;
}
else
{
btn_ZeroFlowCal_Detect.Enabled = false;
btn_ZeroFlowCal_Start.Enabled = false;
cB_ZeroFlowCal_EnableMeter1.Enabled = false;
cB_ZeroFlowCal_EnableMeter2.Enabled = false;
cB_ZeroFlowCal_EnableMeter3.Enabled = false;
cB_ZeroFlowCal_EnableMeter4.Enabled = false;
cB_ZeroFlowCal_EnableMeter5.Enabled = false;
cB_ZeroFlowCal_EnableMeter6.Enabled = false;
cB_ZeroFlowCal_EnableMeter7.Enabled = false;
cB_ZeroFlowCal_EnableMeter8.Enabled = false;
cB_ZeroFlowCal_EnableMeter9.Enabled = false;
cB_ZeroFlowCal_EnableMeter10.Enabled = false;
gB_Settings_AmplitudeTest.Enabled = false;
gB_Settings_ZeroflowOffsetTest.Enabled = false;
gB_Passwords.Enabled = false;
gB_Settings_Preparation.Enabled = false;
gB_Settings_TemperatureCalibration.Enabled = false;
btn_ZeroFlowCal_Pdf.Enabled = false;
btn_ZeroFlowCal_Save.Enabled = false;
btn_ZeroFlowCal_Clear.Enabled = false;
Display.AbortButtonEnabled(true);
cB_AmplitudeTestEnable.Enabled = false;
cB_TempCalEnable.Enabled = false;
cB_ZeroFlowOffsetTestEnable.Enabled = false;
}
}
private void btn_ZeroFlowCal_Start_Click(object sender, EventArgs e)
{
pB_Bubbles1.Visible = true;
#region Definitions and initializations
const int DefaultNumberOfTrials = 15;
System.IO.Ports.SerialPort[] ArrayOfSerialPorts = SerialConfigComportsToArray();
string[] Password = new string[Constants.Core.NumberOfMeters];
bool[] LoginEnable = new bool[Constants.Core.NumberOfMeters];
bool[] PreparationEnable = new bool[Constants.Core.NumberOfMeters];
bool[] AmplitudeEnable = new bool[Constants.Core.NumberOfMeters];
bool[] ZeroFlowOffsetEnable = new bool[Constants.Core.NumberOfMeters];
bool[] TempCalEnable = new bool[Constants.Core.NumberOfMeters];
bool[] CompletionEnable = new bool[Constants.Core.NumberOfMeters];
bool[] LoginFailed = new bool[Constants.Core.NumberOfMeters];
bool[] PreparationFailed = new bool[Constants.Core.NumberOfMeters];
bool[] AmplitudeFailed = new bool[Constants.Core.NumberOfMeters];
bool[] ZeroFlowOffsetFailed = new bool[Constants.Core.NumberOfMeters];
bool[] TempCalFailed = new bool[Constants.Core.NumberOfMeters];
bool[] CompletionFailed = new bool[Constants.Core.NumberOfMeters];
bool[] OK = new bool[Constants.Core.NumberOfMeters];
bool[] EmptyPipeCheckEnable = new bool[Constants.Core.NumberOfMeters];
bool[] EmptyPipeCheckFailed = new bool[Constants.Core.NumberOfMeters];
bool[] MeterSelected = new bool[Constants.Core.NumberOfMeters];
MeterSelected[Constants.Core.Meter1] = cB_ZeroFlowCal_EnableMeter1.Checked;
MeterSelected[Constants.Core.Meter2] = cB_ZeroFlowCal_EnableMeter2.Checked;
MeterSelected[Constants.Core.Meter3] = cB_ZeroFlowCal_EnableMeter3.Checked;
MeterSelected[Constants.Core.Meter4] = cB_ZeroFlowCal_EnableMeter4.Checked;
MeterSelected[Constants.Core.Meter5] = cB_ZeroFlowCal_EnableMeter5.Checked;
MeterSelected[Constants.Core.Meter6] = cB_ZeroFlowCal_EnableMeter6.Checked;
MeterSelected[Constants.Core.Meter7] = cB_ZeroFlowCal_EnableMeter7.Checked;
MeterSelected[Constants.Core.Meter8] = cB_ZeroFlowCal_EnableMeter8.Checked;
MeterSelected[Constants.Core.Meter9] = cB_ZeroFlowCal_EnableMeter9.Checked;
MeterSelected[Constants.Core.Meter10] = cB_ZeroFlowCal_EnableMeter10.Checked;
bool StopSequence = false;
for (int Meter = 0; Meter < Constants.Core.NumberOfMeters; Meter++)
{
Password[Meter] = String.Empty;
LoginEnable[Meter] = SerialPortOpenFlag[Meter] & SerialPortOpenFlag[Meter + Constants.Core.NumberOfMeters] & MeterSelected[Meter];
PreparationEnable[Meter] = false;
LoginFailed[Meter] = false;
PreparationFailed[Meter] = false;
AmplitudeFailed[Meter] = false;
ZeroFlowOffsetFailed[Meter] = false;
AmplitudeFailed[Meter] = false;
CompletionFailed[Meter] = false;
OK[Meter] = false;
EmptyPipeCheckEnable[Meter] = false;
EmptyPipeCheckFailed[Meter] = false;
}
#endregion
#region Login
AbortFlag = false;
SetControlElements(false);
Display.DebugCrcIndicatorVisible(false);
Display.SetProgressPanel(StatusPanelItems.Prepare);
if (LoginSequences.CheckIfNoMeterSelected(MeterSelected))
{
MessageBox.Show("No METER selected", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
Display.StatusLabel("Press 'DETECT'");
SetControlElements(true);
return;
}
if (!LoginSequences.CheckIfPortFlagsValid(MeterSelected, SerialPortOpenFlag))
{
Display.StatusLabel("Press 'DETECT'");
Display.AbortButtonEnabled(false);
MessageBox.Show("Please repeat 'DETECT'", "Bad operation", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
#endregion
#region Password check
Display.StatusLabel("Wait until LOGIN has finished");
if (LoginEnable[Constants.Core.Meter1])
{
if (Misc.OnlyHexInString(rTB_PasswordMeter1.Text) && (rTB_PasswordMeter1.Text.Count() == rTB_PasswordMeter1.MaxLength))
Password[Constants.Core.Meter1] = rTB_PasswordMeter1.Text;
else
{
Display.StatusLabel("Press 'DETECT'");
Display.SetProgressPanel(StatusPanelItems.None);
Display.AbortButtonEnabled(false);
MessageBox.Show("PASSWORD invalid at METER1", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
}
if (LoginEnable[Constants.Core.Meter2])
{
if (Misc.OnlyHexInString(rTB_PasswordMeter2.Text) && (rTB_PasswordMeter2.Text.Count() == rTB_PasswordMeter2.MaxLength))
Password[Constants.Core.Meter2] = rTB_PasswordMeter2.Text;
else
{
Display.StatusLabel("Press 'DETECT'");
Display.SetProgressPanel(StatusPanelItems.None);
Display.AbortButtonEnabled(false);
MessageBox.Show("PASSWORD invalid at METER2", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
}
if (LoginEnable[Constants.Core.Meter3])
{
if (Misc.OnlyHexInString(rTB_PasswordMeter3.Text) && (rTB_PasswordMeter3.Text.Count() == rTB_PasswordMeter3.MaxLength))
Password[Constants.Core.Meter3] = rTB_PasswordMeter3.Text;
else
{
Display.StatusLabel("Press 'DETECT'");
Display.SetProgressPanel(StatusPanelItems.None);
Display.AbortButtonEnabled(false);
MessageBox.Show("PASSWORD invalid at METER3", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
}
if (LoginEnable[Constants.Core.Meter4])
{
if (Misc.OnlyHexInString(rTB_PasswordMeter4.Text) && (rTB_PasswordMeter4.Text.Count() == rTB_PasswordMeter4.MaxLength))
Password[Constants.Core.Meter4] = rTB_PasswordMeter4.Text;
else
{
Display.StatusLabel("Press 'DETECT'");
Display.SetProgressPanel(StatusPanelItems.None);
Display.AbortButtonEnabled(false);
MessageBox.Show("PASSWORD invalid at METER4", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
}
if (LoginEnable[Constants.Core.Meter5])
{
if (Misc.OnlyHexInString(rTB_PasswordMeter5.Text) && (rTB_PasswordMeter5.Text.Count() == rTB_PasswordMeter5.MaxLength))
Password[Constants.Core.Meter5] = rTB_PasswordMeter5.Text;
else
{
Display.StatusLabel("Press 'DETECT'");
Display.SetProgressPanel(StatusPanelItems.None);
Display.AbortButtonEnabled(false);
MessageBox.Show("PASSWORD invalid at METER5", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
}
if (LoginEnable[Constants.Core.Meter6])
{
if (Misc.OnlyHexInString(rTB_PasswordMeter6.Text) && (rTB_PasswordMeter6.Text.Count() == rTB_PasswordMeter6.MaxLength))
Password[Constants.Core.Meter6] = rTB_PasswordMeter6.Text;
else
{
Display.StatusLabel("Press 'DETECT'");
Display.SetProgressPanel(StatusPanelItems.None);
Display.AbortButtonEnabled(false);
MessageBox.Show("PASSWORD invalid at METER6", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
}
if (LoginEnable[Constants.Core.Meter7])
{
if (Misc.OnlyHexInString(rTB_PasswordMeter7.Text) && (rTB_PasswordMeter7.Text.Count() == rTB_PasswordMeter7.MaxLength))
Password[Constants.Core.Meter7] = rTB_PasswordMeter7.Text;
else
{
Display.StatusLabel("Press 'DETECT'");
Display.SetProgressPanel(StatusPanelItems.None);
Display.AbortButtonEnabled(false);
MessageBox.Show("PASSWORD invalid at METER7", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
}
if (LoginEnable[Constants.Core.Meter8])
{
if (Misc.OnlyHexInString(rTB_PasswordMeter8.Text) && (rTB_PasswordMeter8.Text.Count() == rTB_PasswordMeter8.MaxLength))
Password[Constants.Core.Meter8] = rTB_PasswordMeter8.Text;
else
{
Display.StatusLabel("Press 'DETECT'");
Display.SetProgressPanel(StatusPanelItems.None);
Display.AbortButtonEnabled(false);
MessageBox.Show("PASSWORD invalid at METER8", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
}
if (LoginEnable[Constants.Core.Meter9])
{
if (Misc.OnlyHexInString(rTB_PasswordMeter9.Text) && (rTB_PasswordMeter9.Text.Count() == rTB_PasswordMeter9.MaxLength))
Password[Constants.Core.Meter9] = rTB_PasswordMeter9.Text;
else
{
Display.StatusLabel("Press 'DETECT'");
Display.SetProgressPanel(StatusPanelItems.None);
Display.AbortButtonEnabled(false);
MessageBox.Show("PASSWORD invalid at METER9", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
}
if (LoginEnable[Constants.Core.Meter10])
{
if (Misc.OnlyHexInString(rTB_PasswordMeter10.Text) && (rTB_PasswordMeter10.Text.Count() == rTB_PasswordMeter10.MaxLength))
Password[Constants.Core.Meter10] = rTB_PasswordMeter10.Text;
else
{
Display.StatusLabel("Press 'DETECT'");
Display.SetProgressPanel(StatusPanelItems.None);
Display.AbortButtonEnabled(false);
MessageBox.Show("PASSWORD invalid at METER10", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
}
#endregion
#region Login
//Login:
bool Aborted = false;
LoginFailed = LoginSequences.Total(LoginEnable, ArrayOfSerialPorts, ref CommandInterfaceTotal, Password, DefaultNumberOfTrials, out Aborted);
pB_Bubbles1.Visible = false;
OK = DisplayGetSequenceResult(LoginEnable, LoginFailed, "LOGIN sequence", out StopSequence, Aborted);
Display.MeterStatusGreenRed(OK, LoginEnable);
if (StopSequence)
{
Display.SetProgressPanel(StatusPanelItems.None);
GenesisZeroFlow.Display.AbortButtonEnabled(false);
CloseComportsSequence();
SetControlElements(true);
return;
}
#endregion
//goto skippreperation;
#region Preparation
//Preparation:
if (GenesisZeroFlow._GenesisZeroFlow.AbortFlag == false)
{
PreparationEnable = OK;
Display.SetProgressPanel(StatusPanelItems.Prepare);
Display.DebugMessage("APPLICATION:\t\t PREPARATION sequence started\n");
Display.StatusLabel("Wait until PREPARATION has finished");
}
else
{
Display.DebugMessage("APPLICATION:\t\t PREPARATION sequence aborted\n");
Display.DebugMessage(Debugmessages.Line);
Display.StatusLabel("Press 'DETECT'");
Display.DebugCrcIndicatorVisible(false);
Display.AbortButtonEnabled(false);
CloseComportsSequence();
MessageBox.Show("ZEROFLOW CALIBRATION sequence aborted", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
PreparationFailed = PreparationSequences.Total(PreparationEnable, ArrayOfSerialPorts, CommandInterfaceTotal, Password, DefaultNumberOfTrials, out Aborted, GlobalCulture);
OK = DisplayGetSequenceResult(PreparationEnable, PreparationFailed, "PREPARATION sequence", out StopSequence, Aborted);
Display.MeterStatusGreenRed(OK, PreparationEnable);
if (StopSequence)
{
Display.SetProgressPanel(StatusPanelItems.None);
Display.DebugCrcIndicatorVisible(false);
Display.AbortButtonEnabled(false);
CloseComportsSequence();
SetControlElements(true);
return;
}
#region Empty pipe mode check
Display.DebugMessage("APPLICATION:\t\t EMPTY PIPE CHECK sequence started\n");
EmptyPipeCheckEnable = OK;
EmptyPipeCheckFailed = EmptyPipeCheckSequence(EmptyPipeCheckEnable, out Aborted);
OK = DisplayGetSequenceResult(EmptyPipeCheckEnable, EmptyPipeCheckFailed, "EMPTY PIPE CHECK sequence", out StopSequence, Aborted);
Display.MeterStatusGreenRed(OK, LoginEnable);
if (StopSequence)
{
Display.SetProgressPanel(StatusPanelItems.None);
Display.DebugCrcIndicatorVisible(false);
Display.AbortButtonEnabled(false);
CloseComportsSequence();
SetControlElements(true);
return;
}
Display.ShowResultStatus("EMPTY PIPE CHECK: ", OK);
#endregion
#region Wait for two minutes
Display.WaitForStabilization(OK, StopSequence, (int)nUD_Settings_Preparation_StabiTime.Value, out Aborted);
OK = DisplayGetSequenceResult(EmptyPipeCheckEnable, EmptyPipeCheckFailed, "WAIT FOR STABILIZATION sequence", out StopSequence, Aborted);
Display.MeterStatusGreenRed(OK, LoginEnable);
if (StopSequence)
{
Display.SetProgressPanel(StatusPanelItems.None);
Display.DebugCrcIndicatorVisible(false);
Display.AbortButtonEnabled(false);
CloseComportsSequence();
SetControlElements(true);
return;
}
#endregion
#endregion
#region Bubbles
pB_Bubbles1.Visible = true;
Misc.WaitNSeconds(1);
pB_Bubbles1.Visible = false;
#endregion
#region Skip amplitude test (Don't care that 'goto' is not MISRA compliant)
if (!cB_AmplitudeTestEnable.Checked)
goto ZeroFlowOffsetTest;
#endregion
#region Amplitude test
//Amptest:
if (GenesisZeroFlow._GenesisZeroFlow.AbortFlag == false)
{
AmplitudeEnable = OK;
Display.SetProgressPanel(StatusPanelItems.Amplitude);
Display.DebugMessage("APPLICATION:\t\t AMPLITUDE TEST sequence started\n");
Display.StatusLabel("Wait until AMPLITUDE TEST has finished");
Display.ShowResultStatus("Enable AMPLITUDE TEST sequence", AmplitudeEnable);
Display.DebugCrcIndicatorVisible(true);
}
else
{
Display.DebugCrcIndicatorVisible(false);
Display.StatusLabel("Press 'DETECT'");
Display.DebugMessage("APPLICATION:\t\t ZEROFLOW CALIBRATION sequence aborted\n");
Display.DebugMessage(Debugmessages.Line);
Display.AbortButtonEnabled(false);
CloseComportsSequence();
MessageBox.Show("ZEROFLOW CALIBRATION sequence aborted", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
AmplitudeFailed = AmplitudeSequences.Total(AmplitudeEnable, ArrayOfSerialPorts, CommandInterfaceTotal, Password, DefaultNumberOfTrials, (int)nUD_PercentageStart.Value, (int)nUD_PercentageStop.Value, (int)nUD_Settings_AmplitudeTestLowerLimit.Value, (int)nUD_Settings_AmplitudeTestUpperLimit.Value, (int)nUD_Settings_AmplitudeTestMinDistance.Value, out Aborted);
Display.ShowResultStatus("AMPLITUDE TEST failed: ", AmplitudeFailed);
OK = DisplayGetSequenceResult(AmplitudeEnable, AmplitudeFailed, "AMPLITUDE TEST sequence", out StopSequence, Aborted);
Display.MeterStatusGreenRed(OK, AmplitudeEnable);
if (StopSequence)
{
Display.SetProgressPanel(StatusPanelItems.None);
Display.DebugCrcIndicatorVisible(false);
Display.AbortButtonEnabled(false);
CloseComportsSequence();
SetControlElements(true);
return;
}
#endregion
#region Zero flow offset tests
#region Skip Offset test (Don't care that 'goto' is not MISRA compliant)
ZeroFlowOffsetTest:
if (!cB_ZeroFlowOffsetTestEnable.Checked)
goto Tempcal;
#endregion
if (GenesisZeroFlow._GenesisZeroFlow.AbortFlag == false)
{
ZeroFlowOffsetEnable = OK;
Display.ShowResultStatus("Zeroflow offset test enable = ", ZeroFlowOffsetEnable);
Display.SetProgressPanel(StatusPanelItems.Offset);
Display.DebugMessage("APPLICATION:\t\t ZEROFLOW OFFSET TEST sequence started\n");
Display.StatusLabel("Wait until ZEROFLOW OFFSET TEST has finished");
}
else
{
Display.StatusLabel("Press 'DETECT'");
Display.DebugCrcIndicatorVisible(false);
Display.AbortButtonEnabled(false);
CloseComportsSequence();
MessageBox.Show("ZEROFLOW CALIBRATION sequence aborted", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
ZeroFlowOffsetFailed = ZeroOffsetSequences.Total(ZeroFlowOffsetEnable, ArrayOfSerialPorts, CommandInterfaceTotal, Password, DefaultNumberOfTrials, (int)nUD_Settings_ZeroflowOffsetTestSettlingTime.Value, (Int16)nUD_Settings_ZeroflowOffsetTestLowerLimit.Value, (Int16)nUD_Settings_ZeroflowOffsetTestUpperLimit.Value, (int)nUD_Settings_ZeroflowOffsetTestOffsetLimit.Value, (int)nUD_Settings_ZeroflowOffsetTestNumberOfLines.Value, out Aborted, GlobalCulture);
OK = DisplayGetSequenceResult(ZeroFlowOffsetEnable, ZeroFlowOffsetFailed, "ZEROFLOW OFFSET TEST sequence", out StopSequence, Aborted);
Display.MeterStatusGreenRed(OK, ZeroFlowOffsetEnable);
if (StopSequence)
{
Display.SetProgressPanel(StatusPanelItems.None);
Display.DebugCrcIndicatorVisible(false);
Display.AbortButtonEnabled(false);
CloseComportsSequence();
SetControlElements(true);
return;
}
#endregion
#region Bubbles
pB_Bubbles1.Visible = true;
Misc.WaitNSeconds(1);
pB_Bubbles1.Visible = false;
#endregion
#region Temperature calibration
#region Skip temperature calibration (Hello Mr. Reviewer, don't care that 'goto' is not MISRA compliant!)
Tempcal:
if (!cB_TempCalEnable.Checked)
goto Completion;
#endregion
if (GenesisZeroFlow._GenesisZeroFlow.AbortFlag == false)
{
TempCalEnable = OK;
Display.SetProgressPanel(StatusPanelItems.TempCal);
Display.DebugMessage("APPLICATION:\t\t TEMPERATURE CALIBRATION sequence started\n");
Display.StatusLabel("Wait until TEMPERATURE CALIBRATION has finished");
Display.ShowResultStatus("Enable TEMPERATURE CALIBRATION sequence", TempCalEnable);
Display.DebugCrcIndicatorVisible(true);
Display.TemperatureField();
while (WaitForTemperatureField) { Misc.WaitNSeconds(1); }
}
else
{
Display.DebugCrcIndicatorVisible(false);
Display.StatusLabel("Press 'DETECT'");
Display.DebugMessage("APPLICATION:\t\t ZEROFLOW CALIBRATION sequence aborted\n");
Display.DebugMessage(Debugmessages.Line);
Display.AbortButtonEnabled(false);
CloseComportsSequence();
MessageBox.Show("ZEROFLOW CALIBRATION sequence aborted", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
TempCalFailed = TempCalibrationSequences.Total(TempCalEnable, ArrayOfSerialPorts, CommandInterfaceTotal, Password, DefaultNumberOfTrials, out Aborted);
Display.ShowResultStatus("TEMPERATURE CALIBRATION failed: ", TempCalFailed);
OK = DisplayGetSequenceResult(TempCalEnable, TempCalFailed, "TEMPERATURE CALIBRATION sequence", out StopSequence, Aborted);
Display.MeterStatusGreenRed(OK, TempCalEnable);
if (StopSequence)
{
Display.SetProgressPanel(StatusPanelItems.None);
Display.DebugCrcIndicatorVisible(false);
Display.AbortButtonEnabled(false);
CloseComportsSequence();
SetControlElements(true);
return;
}
#endregion
#region Bubbles
pB_Bubbles1.Visible = true;
Misc.WaitNSeconds(1);
pB_Bubbles1.Visible = false;
#endregion
#region Completion
Completion:
if (GenesisZeroFlow._GenesisZeroFlow.AbortFlag == false)
{
CompletionEnable = OK;
Display.ShowResultStatus("CompletionEnable = ", CompletionEnable);
Display.SetProgressPanel(StatusPanelItems.Completion);
Display.DebugMessage("APPLICATION:\t\t COMPLETION sequence started\n");
Display.StatusLabel("Wait until COMPLETION has finished");
Display.DebugCrcIndicatorVisible(false);
}
else
{
Display.DebugMessage("APPLICATION:\t\t ZEROFLOW CALIBRATION sequence aborted\n");
Display.DebugMessage(Debugmessages.Line);
Display.StatusLabel("Press 'DETECT'");
Display.DebugCrcIndicatorVisible(false);
Display.AbortButtonEnabled(false);
CloseComportsSequence();
MessageBox.Show("ZEROFLOW CALIBRATION sequence aborted", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
CompletionFailed = CompletionSequences.Total(CompletionEnable, ArrayOfSerialPorts, CommandInterfaceTotal, Password, DefaultNumberOfTrials, out Aborted);
OK = DisplayGetSequenceResult(CompletionEnable, CompletionFailed, "COMPLETION sequence", out StopSequence, Aborted);
Display.MeterStatusGreenRed(OK, CompletionEnable);
if (StopSequence)
{
Display.SetProgressPanel(StatusPanelItems.None);
Display.StatusLabel("Press 'DETECT'");
Display.DebugCrcIndicatorVisible(false);
Display.DebugMessage("APPLICATION:\t\t ZEROFLOW CALIBRATION sequence failed\n");
Display.DebugMessage(Debugmessages.Line);
Display.AbortButtonEnabled(false);
CloseComportsSequence();
MessageBox.Show("ZEROFLOW CALIBRATION sequence failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
SetControlElements(true);
return;
}
Display.DebugMessage("APPLICATION:\t\t ZEROFLOW CALIBRATION sequence succesful\n");
Display.DebugMessage(Debugmessages.Line);
Display.AbortButtonEnabled(false);
CloseComportsSequence();
MessageBox.Show("ZEROFLOW CALIBRATION sequence successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
Display.StatusLabel("Press 'DETECT'");
SetControlElements(true);
#endregion
#region Bubbles
pB_Bubbles1.Visible = true;
Misc.WaitNSeconds(1);
pB_Bubbles1.Visible = false;
#endregion
}
private void btn_ZeroFlowCal_Abort_Click(object sender, EventArgs e)
{
DialogResult AskForActions = DialogResult.None;
Display.AbortButtonEnabled(false);
AskForActions = MessageBox.Show("Are you sure?", "Form closing", MessageBoxButtons.OKCancel, MessageBoxIcon.Error);
if (AskForActions == DialogResult.OK)
{
AbortFlag = true;
}
else
{
AbortFlag = false;
Display.AbortButtonEnabled(true);
}
}
private void btn_ZeroFlowCal_Clear_Click(object sender, EventArgs e)
{
#region Bubbles
pB_Bubbles1.Visible = true;
Misc.WaitNSeconds(1);
pB_Bubbles1.Visible = false;
#endregion
rTB_ZeroFlowCal.Clear();
}
private void btn_ZeroFlowCal_Save_Click(object sender, EventArgs e)
{
#region Definitions and initializations
string SaveDataPathRaw = string.Empty;
bool 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);
pB_Bubbles1.Visible = false;
#endregion
#region Logfile
try
{
RawDialogOK = Files.SaveFiledialogTxt("txt", out SaveDataPathRaw, ClosingPath, out TimeForHeader);
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", GlobalCulture), string.Empty);
MessageBox.Show("Log file storage failed", "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;
bool RawDialogOK = false;
string Username = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
string ClosingPath = DataLogging.DefaultPath;
string TimeForHeader = string.Empty;
XImage Logo = pB_Logo1.Image;
PdfDocument LogReport = new PdfDocument();
LogReport.Info.Title = "GENESIS Zeroflow calibration tool logfile";
LogReport.Info.Author = Username;
#endregion
#region Bubbles
pB_Bubbles1.Visible = true;
Misc.WaitNSeconds(1);
pB_Bubbles1.Visible = false;
#endregion
#region Logfile
try
{
RawDialogOK = Files.SaveFiledialogPdf(out SaveDataPathPdf, ClosingPath, out TimeForHeader);
if (RawDialogOK)
{
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);
}
}
catch (Exception ex)
{
ErrorLog.Log(LogErrReason.Exeption, "btn_ZeroFlowCal_Pdf_Click() failed", "0x" + ex.HResult.ToString("X", GlobalCulture), string.Empty);
MessageBox.Show("PDF log file storage failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
#endregion
public void EnableMaintab()
{
tab_Maintab.Enabled = true;
}
public List<double>[] GetAmplitudeValuesPositive(int meterNumber)
{
List<double>[] data = new List<double>[Constants.Core.NumberOfPaths];
data = AmplitudeValuesPositive[meterNumber];
return data;
}
public void ClearAmplitudeValuesPositive(int meterNumber)
{
if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
{
GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<int>)ClearAmplitudeValuesPositive, meterNumber);
return;
}
AmplitudeValuesPositive[meterNumber][Constants.Core.PATH0].Clear();
AmplitudeValuesPositive[meterNumber][Constants.Core.PATH1].Clear();
AmplitudeValuesPositive[meterNumber][Constants.Core.PATH2].Clear();
// Display.DebugMessage("Positive Amplitudenwerte = " + AmplitudeValuesPositive[meterNumber][Constants.Core.PATH0].Count().ToString(culture) + "\n");
}
public void ClearAmplitudeValuesNegative(int meterNumber)
{
if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
{
GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<int>)ClearAmplitudeValuesNegative, meterNumber);
return;
}
AmplitudeValuesNegative[meterNumber][Constants.Core.PATH0].Clear();
AmplitudeValuesNegative[meterNumber][Constants.Core.PATH1].Clear();
AmplitudeValuesNegative[meterNumber][Constants.Core.PATH2].Clear();
// Display.DebugMessage("Negative Amplitudenwerte = " + AmplitudeValuesNegative[meterNumber][Constants.Core.PATH0].Count().ToString(culture) + "\n");
}
public List<double>[] GetAmplitudeValuesNegative(int meterNumber)
{
List<double>[] data = new List<double>[Constants.Core.NumberOfPaths];
data = AmplitudeValuesNegative[meterNumber];
return data;
}
public void ClearBadDataCounter(int meterNumber)
{
if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
{
GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<int>)ClearBadDataCounter, meterNumber);
return;
}
BadDataCounterZeroFlowTest[meterNumber][Constants.Core.PATH0] = 0;
BadDataCounterZeroFlowTest[meterNumber][Constants.Core.PATH1] = 0;
BadDataCounterZeroFlowTest[meterNumber][Constants.Core.PATH2] = 0;
// Display.DebugMessage("Schlechtdatenzaehler = " + BadDataCounterZeroFlowTest[meterNumber][Constants.Core.PATH0] + "\n");
}
public int[] GetBadDataCounter(int meterNumber)
{
int[] BadData = new int[Constants.Core.NumberOfPaths];
BadData[Constants.Core.PATH0] = BadDataCounterZeroFlowTest[meterNumber][Constants.Core.PATH0];
BadData[Constants.Core.PATH1] = BadDataCounterZeroFlowTest[meterNumber][Constants.Core.PATH1];
BadData[Constants.Core.PATH2] = BadDataCounterZeroFlowTest[meterNumber][Constants.Core.PATH2];
return BadData;
}
public void ClearLineCounterZeroFlow(int meterNumber)
{
if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
{
GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<int>)ClearLineCounterZeroFlow, meterNumber);
return;
}
LineCounterZeroFlowTest[meterNumber][Constants.Core.PATH0] = 0;
LineCounterZeroFlowTest[meterNumber][Constants.Core.PATH1] = 0;
LineCounterZeroFlowTest[meterNumber][Constants.Core.PATH2] = 0;
// Display.DebugMessage("Linienzähler = " + LineCounterZeroFlowTest[meterNumber][Constants.Core.PATH0] + "\n");
}
public int[] GetLineCounterZeroFlow(int meterNumber)
{
int[] Linecounter = new int[Constants.Core.NumberOfPaths];
Linecounter[Constants.Core.PATH0] = LineCounterZeroFlowTest[meterNumber][Constants.Core.PATH0];
Linecounter[Constants.Core.PATH1] = LineCounterZeroFlowTest[meterNumber][Constants.Core.PATH1];
Linecounter[Constants.Core.PATH2] = LineCounterZeroFlowTest[meterNumber][Constants.Core.PATH2];
return Linecounter;
}
public void ClearDeltaTimeOfFlightAverage(int meterNumber)
{
if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
{
GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<int>)ClearDeltaTimeOfFlightAverage, meterNumber);
return;
}
DeltaTimeOfFlightAverage[meterNumber][Constants.Core.PATH0].Clear();
DeltaTimeOfFlightAverage[meterNumber][Constants.Core.PATH1].Clear();
DeltaTimeOfFlightAverage[meterNumber][Constants.Core.PATH2].Clear();
// Display.DebugMessage("Delta time of flight durchschnitt = " + DeltaTimeOfFlightAverage[meterNumber][Constants.Core.PATH0].Count().ToString(GlobalCulture) + "\n");
}
public List<double>[] GetDeltaTimeOfFlightAverage(int meterNumber)
{
List<double>[] Data = new List<double>[Constants.Core.NumberOfPaths];
Data = DeltaTimeOfFlightAverage[meterNumber];
return Data;
}
}
}
Reference in New Issue Copy Permalink