2124 lines
98 KiB
C#
2124 lines
98 KiB
C#
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<Double>[][] AmplitudeValuesUp = new List<Double>[Constants.NumberOfMeters][];
|
|
private List<Double>[][] AmplitudeValuesDown = new List<Double>[Constants.NumberOfMeters][];
|
|
private List<Double>[][] totalTimeOfFlightAverage = new List<Double>[Constants.NumberOfMeters][];
|
|
|
|
|
|
|
|
//private List<Double>[][] Temperatures = new List<Double>[Constants.NumberOfThermometers][];
|
|
|
|
|
|
class tempHelper
|
|
{
|
|
public int meter;
|
|
public int channel;
|
|
|
|
ConcurrentStack<Double> values = new ConcurrentStack<Double>();
|
|
|
|
public Double getAvg()
|
|
{
|
|
var list = values.ToList();
|
|
if (!list.Any()) return 0;
|
|
|
|
var a = list.Average();
|
|
values = new ConcurrentStack<Double>();
|
|
return a;
|
|
}
|
|
|
|
public void add(Double v)
|
|
{
|
|
values.Push(v);
|
|
}
|
|
|
|
}
|
|
|
|
private ConcurrentBag<tempHelper> TemperaturesThreadSafe = new ConcurrentBag<tempHelper>();
|
|
|
|
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<Double>[][] GetTotalTimeOfFlightAverage()
|
|
{
|
|
return (List<Double>[][])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<Int32>[][] DeltaTimeOfFlightAverageRAW = new List<Int32>[Constants.NumberOfMeters][];
|
|
private List<Double>[][] DeltaTimeOfFlightAverage = new List<Double>[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<Byte>[] RxStringCmd = new List<Byte>[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<Byte>();
|
|
#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<Double>[Constants.NumberOfPaths];
|
|
DeltaTimeOfFlightAverageRAW[Meter] = new List<Int32>[Constants.NumberOfPaths];
|
|
DeltaTimeOfFlightAverage[Meter] = new List<Double>[Constants.NumberOfPaths];
|
|
AmplitudeValuesUp[Meter] = new List<Double>[Constants.NumberOfPaths];
|
|
AmplitudeValuesDown[Meter] = new List<Double>[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<Double>();
|
|
DeltaTimeOfFlightAverage[Meter][Path] = new List<Double>();
|
|
DeltaTimeOfFlightAverageRAW[Meter][Path] = new List<Int32>();
|
|
AmplitudeValuesUp[Meter][Path] = new List<Double>();
|
|
AmplitudeValuesDown[Meter][Path] = new List<Double>();
|
|
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<Task>();
|
|
|
|
var listOfMeterFromSource = new Dictionary<IMeter, bool>();
|
|
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<Boolean> 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<Task>();
|
|
var listOfMeterFromSource = new List<IMeter>();
|
|
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<Task<ProcessProgress>> listOfProgrammParts = new List<Task<ProcessProgress>>();
|
|
listOfProgrammParts.Add(new Task<ProcessProgress>(() => { return PrepareTest(currentProgress); }));
|
|
listOfProgrammParts.Add(new Task<ProcessProgress>(() => { return Login(currentProgress); }));
|
|
|
|
|
|
listOfProgrammParts.Add(new Task<ProcessProgress>(() => { return Preparation(currentProgress); }));
|
|
listOfProgrammParts.Add(new Task<ProcessProgress>(() => { return AmplitudeTest(currentProgress); }));
|
|
listOfProgrammParts.Add(new Task<ProcessProgress>(() => { return TemperatureCalibration(currentProgress); }));
|
|
listOfProgrammParts.Add(new Task<ProcessProgress>(() => { return OffsetTest(currentProgress); }));
|
|
listOfProgrammParts.Add(new Task<ProcessProgress>(() => { 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<Double>[] GetAmplitudeValuesUp(UInt16 meterNumber)
|
|
{
|
|
return AmplitudeValuesUp[meterNumber];
|
|
}
|
|
public void ClearAmplitudeValuesUp(UInt16 meterNumber)
|
|
{
|
|
if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<UInt16>)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<UInt16>)ClearAmplitudeValuesDown, meterNumber);
|
|
return;
|
|
}
|
|
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
AmplitudeValuesDown[meterNumber][Path].Clear();
|
|
}
|
|
|
|
public List<Double>[] GetAmplitudeValuesDown(UInt16 meterNumber)
|
|
{
|
|
return AmplitudeValuesDown[meterNumber];
|
|
}
|
|
|
|
public void ClearBadDataCounter(UInt16 meterNumber)
|
|
{
|
|
|
|
if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
|
|
{
|
|
GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<UInt16>)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<UInt16>)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<UInt16>)ClearDeltaTimeOfFlightAverage, meterNumber);
|
|
return;
|
|
}
|
|
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
DeltaTimeOfFlightAverage[meterNumber][Path].Clear();
|
|
DeltaTimeOfFlightAverageRAW[meterNumber][Path].Clear();
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public List<Int32>[] GetDeltaTimeOfFlightAverageRaw(UInt16 meterNumber)
|
|
{
|
|
return DeltaTimeOfFlightAverageRAW[meterNumber];
|
|
}
|
|
|
|
public List<Double>[] 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();
|
|
|
|
// }
|
|
}
|
|
|
|
}
|
|
}
|