8247 lines
395 KiB
C#
8247 lines
395 KiB
C#
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.Tasks;
|
|
using System.Windows.Forms;
|
|
using System.Drawing.Printing;
|
|
using System.Diagnostics;
|
|
using ZedGraph;
|
|
using PdfSharp;
|
|
using PdfSharp.Drawing;
|
|
using PdfSharp.Pdf;
|
|
using System.Media;
|
|
using System.IO;
|
|
using System.Text.RegularExpressions;
|
|
using Newtonsoft.Json;
|
|
using System.Collections.Concurrent;
|
|
using System.Threading;
|
|
using Xylem.Common.Hardware.WaterMeter;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.DataPackages;
|
|
using GenesisDisplayTool;
|
|
|
|
using System.IO.Ports;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.Registers;
|
|
using Xylem.Common.Hardware.WaterMeter;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisCore;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisConfig;
|
|
using Xylem.Common.Hardware.Interfaces.Ports.SerialPorts;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.DataPackages.EventArguments;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.Registers.DataTypes;
|
|
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
|
|
|
|
namespace GenesisDisplayTool
|
|
{
|
|
public partial class GENESIS_DISPLAY_TOOL : Form
|
|
{
|
|
public MeterBatch GlobalMeterBatch = new MeterBatch();
|
|
GenesisMeter currentMeter;
|
|
#region Raw data logging
|
|
Int32 CsvSplitcounter = 0;
|
|
Int32 RawSplitcounter = 0;
|
|
Int32 RawSplitcounterMeter1 = 0;
|
|
Int32 RawSplitcounterMeter2 = 0;
|
|
Int32 RawSplitcounterMeter3 = 0;
|
|
private Int32 RawDataToLogCounter = 0;
|
|
|
|
public String GetJsonDataType()
|
|
{
|
|
String temp = String.Empty;
|
|
if (InvokeRequired)
|
|
{
|
|
lJsonDispDataType.Invoke(new Action(() =>
|
|
{
|
|
temp = lJsonDispDataType.Text;
|
|
}));
|
|
|
|
return temp;
|
|
}
|
|
return lJsonDispDataType.Text;
|
|
}
|
|
public Int32 GetRawDataToLogCounter()
|
|
{
|
|
return RawDataToLogCounter;
|
|
}
|
|
|
|
public TabPage GetSelectedTabPage()
|
|
{
|
|
return tab_Maintab.SelectedTab;
|
|
}
|
|
public TabPage tabPageJson()
|
|
{
|
|
return tab_Json;
|
|
}
|
|
|
|
|
|
public void SetRawDataToLogCounter(Int32 value)
|
|
{
|
|
RawDataToLogCounter = value;
|
|
}
|
|
private Int32[] CsvDataToLogCounter = new Int32[Constants.NumberOfPaths] { 0, 0, 0 };
|
|
public Int32[] GetCsvDataToLogCounter()
|
|
{
|
|
return CsvDataToLogCounter;
|
|
}
|
|
private Int32 RawDataToLogCounterMeter1 = 0;
|
|
public Int32 GetRawDataToLogCounterMeter1()
|
|
{
|
|
return RawDataToLogCounterMeter1;
|
|
}
|
|
public void SetRawDataToLogCounterMeter1(Int32 value)
|
|
{
|
|
RawDataToLogCounterMeter1 = value;
|
|
}
|
|
private Int32 RawDataToLogCounterMeter2 = 0;
|
|
public Int32 GetRawDataToLogCounterMeter2()
|
|
{
|
|
return RawDataToLogCounterMeter2;
|
|
}
|
|
public void SetRawDataToLogCounterMeter2(Int32 value)
|
|
{
|
|
RawDataToLogCounterMeter2 = value;
|
|
}
|
|
private Int32 RawDataToLogCounterMeter3 = 0;
|
|
public Int32 GetRawDataToLogCounterMeter3()
|
|
{
|
|
return RawDataToLogCounterMeter3;
|
|
}
|
|
public void SetRawDataToLogCounterMeter3(Int32 value)
|
|
{
|
|
RawDataToLogCounterMeter3 = value;
|
|
}
|
|
#endregion
|
|
|
|
public Boolean NudEnable { get; set; } = false;
|
|
private CultureInfo globalCulture = CultureInfo.CreateSpecificCulture("en-US");
|
|
|
|
public CultureInfo GetGlobalCulture()
|
|
{
|
|
return globalCulture;
|
|
}
|
|
public Int32 DisplayOnTab = (Int32)SelectedTab.None;
|
|
|
|
private Boolean MassLogging = true;
|
|
private Boolean StartUpDisable = true; // to suppress checked change event of check boxes for switching between single and mass logging during start up
|
|
//private Boolean EnableMassLoggingCheckbox = false;
|
|
private CmdInterface CommandInterface1 = new CmdInterface();
|
|
private CmdInterface CommandInterface2 = new CmdInterface();
|
|
private CmdInterface CommandInterface3 = new CmdInterface();
|
|
|
|
private SerialConfig SerialConfig_CmdMeter1 = new SerialConfig(); // Former SerialConfig1
|
|
private SerialConfig SerialConfig_CmdMeter2 = new SerialConfig(); // Former SerialConfig
|
|
private SerialConfig SerialConfig_CmdMeter3 = new SerialConfig(); // Former SerialConfig
|
|
private SerialConfig SerialConfig_DataMeter1 = new SerialConfig(); // Former SerialConfig2
|
|
private SerialConfig SerialConfig_DataMeter2 = new SerialConfig(); // Former SerialConfig3
|
|
private SerialConfig SerialConfig_DataMeter3 = new SerialConfig(); // Former SerialConfig4
|
|
|
|
private PrintDocument docToPrint =
|
|
new PrintDocument();
|
|
|
|
#region Counter for diagnosis
|
|
private UInt16 ElapsedCounterTofMean = 0;
|
|
private UInt16 ElapsedCounterDifTofMean = 0;
|
|
private UInt16 ElapsedCounterMultiHitMean = 0;
|
|
private UInt16 ElapsedCounterOthersMean = 0;
|
|
private UInt16 ElapsedCounterStdDeviation = 0;
|
|
private UInt16 ElapsedCounterTemperatureMean = 0;
|
|
private UInt16 ElapsedCounterFlowMean = 0;
|
|
private UInt16 InvokeMainloopExceptionsCounter = 0;
|
|
private UInt16 SumOfAllElapsedValues = 0;
|
|
|
|
#endregion
|
|
#region Global parameters
|
|
#region Logging parameters/ flags
|
|
|
|
private Boolean[] RawLoggingEnable = new Boolean[Constants.NumberOfPaths] { false, false, false };
|
|
private Boolean RawLoggingSingleMeterEnable = false;
|
|
public void SetRawLoggingSingleMeterEnable(Boolean value)
|
|
{
|
|
RawLoggingSingleMeterEnable = value;
|
|
}
|
|
private Boolean LoggingCsvEn;
|
|
Int32[] CsvIndexValue = new Int32[Constants.NumberOfPaths] { 0, 0, 0 };
|
|
#endregion
|
|
#region Graph parameters
|
|
Double MaingraphPreviousValue = 0;
|
|
private zedGraphParameters ParamsMainGraph = new zedGraphParameters();
|
|
|
|
|
|
public void SetParamsMainGraph(zedGraphParameters parameters)
|
|
{
|
|
ParamsMainGraph = parameters;
|
|
}
|
|
public zedGraphParameters GetParamsMainGraph()
|
|
{
|
|
return ParamsMainGraph;
|
|
}
|
|
|
|
public void SetTitleMainGraph(String title)
|
|
{
|
|
ParamsMainGraph.Title = title;
|
|
}
|
|
|
|
public ZedGraphControl GetMainGraph()
|
|
{
|
|
return zGC_MainGraph;
|
|
}
|
|
|
|
private zedGraphParameters[] ParamsStdDev = new zedGraphParameters[Constants.NumberOfPaths];
|
|
|
|
public PointPairList[] GraphListMainWindow = new PointPairList[Constants.NumberOfPaths];
|
|
|
|
public void SetGraphListMainWindow(PointPairList[] graphList)
|
|
{
|
|
GraphListMainWindow = graphList;
|
|
}
|
|
public PointPairList[] GetGraphListMainWindow()
|
|
{
|
|
return (PointPairList[])GraphListMainWindow.Clone();
|
|
}
|
|
|
|
private PointPairList[] GraphListDatabase = new PointPairList[Constants.NumberOfPaths];
|
|
public List<PointPairList>[] GraphListMainTotal = new List<PointPairList>[Constants.NumberOfPaths];
|
|
public PointPairList[] GetGraphListMainTotal()
|
|
{
|
|
return (PointPairList[])GraphListMainTotal.Clone();
|
|
}
|
|
public void SetGraphListMainTotal(List<PointPairList>[] graphList)
|
|
{
|
|
GraphListMainTotal = graphList;
|
|
}
|
|
private PointPairList[,] GraphListStdDevWindow = new PointPairList[Constants.NumberOfPaths, 10];
|
|
private List<PointPairList>[,] GraphListStdDevTotal = new List<PointPairList>[Constants.NumberOfPaths, 10];
|
|
|
|
|
|
private UInt32[] GraphCounterDataStdDevTotal = new UInt32[Constants.NumberOfPaths] { 0, 0, 0 };
|
|
private UInt32[] GraphCounterDataMainTotal = new UInt32[Constants.NumberOfPaths] { 0, 0, 0 };
|
|
public void SetGraphCounterDataMainTotal(UInt32 value, UInt32 path)
|
|
{
|
|
GraphCounterDataMainTotal[path] = value;
|
|
}
|
|
private String MainGraphTitle = String.Empty;
|
|
#endregion
|
|
#region Data storage parameters
|
|
private String SaveDataPathRaw = String.Empty;
|
|
private String SaveDataPathMeter1 = String.Empty;
|
|
private String SaveDataPathMeter2 = String.Empty;
|
|
private String SaveDataPathMeter3 = String.Empty;
|
|
private String SaveDataPathCsv = String.Empty;
|
|
private String SaveDataPathWord = String.Empty;
|
|
private String SaveDataPathRawRtb = String.Empty;
|
|
private String DefaultLogDirectory = String.Empty;
|
|
private String DefaultReportDirectory = String.Empty;
|
|
private String DefaultImagesDirectory = String.Empty;
|
|
private String DefaultCsvDirectory = String.Empty;
|
|
private String DefaultJsonDirectory = String.Empty;
|
|
private String JsonDataPath = String.Empty;
|
|
private String[] DataToLog = new String[Constants.NumberOfMeters] { String.Empty, String.Empty, String.Empty };
|
|
private String[] CsvDataToLog = new String[Constants.NumberOfPaths] { String.Empty, String.Empty, String.Empty };
|
|
#endregion
|
|
#region Decoded data parameters
|
|
#region >>>> Central exchange object <<<<
|
|
// ****** The most important object ******
|
|
// ***************************************
|
|
private DecodedData[] Decoded = DecodedDataHelper.getDefaultDecodedDataArray(Constants.NumberOfPaths); // <== !!!!!!!!!!!!!!!!!!
|
|
private Boolean[] ValidData = new Boolean[Constants.NumberOfMeters] { false, false, false };
|
|
private String[] Output = new String[Constants.NumberOfMeters] { String.Empty, String.Empty, String.Empty };
|
|
// ***************************************
|
|
// ***************************************
|
|
#endregion
|
|
#region Standard deviation
|
|
private UInt16[] TelegramCounterStdDeviationSingle = new UInt16[Constants.NumberOfPaths] { 0, 0, 0 };
|
|
private UInt16[] TelegramCounterStdDeviationMultihit = new UInt16[Constants.NumberOfPaths] { 0, 0, 0 };
|
|
private List<List<Double>>[] ProcessingStdDeviation = new List<List<Double>>[Constants.NumberOfPaths];
|
|
private List<Double>[] Processing3HitsStdDeviation = new List<Double>[Constants.NumberOfPaths];
|
|
private List<Double>[] Processing8HitsStdDeviation = new List<Double>[Constants.NumberOfPaths];
|
|
#endregion
|
|
#region Mean values
|
|
#region TOF-values
|
|
private UInt16[] TelegramCounterTofMean = new UInt16[Constants.NumberOfPaths] { 0, 0, 0 };
|
|
private List<List<Double>>[] ProcessingTofUpMean = new List<List<Double>>[Constants.NumberOfPaths];
|
|
private List<List<Double>>[] ProcessingTofDownMean = new List<List<Double>>[Constants.NumberOfPaths];
|
|
#endregion
|
|
#region DIF TOF values
|
|
private UInt16[] TelegramCounterDifTofMean = new UInt16[Constants.NumberOfPaths] { 0, 0, 0 };
|
|
private List<List<Double>>[] ProcessingDifTofMean = new List<List<Double>>[Constants.NumberOfPaths];
|
|
#endregion
|
|
#region MULTIHIT / 3Hits, 8 Hits
|
|
private UInt16[] TelegramCounterMultiHitMean = new UInt16[Constants.NumberOfPaths] { 0, 0, 0 };// to switch between initial filling and moving average mode
|
|
private List<Double> Processing3HitsMean = new List<Double>(); // input value for mean calculation. Contains three values and is cleared afterwards
|
|
private List<Double>[] Processing3HitsTotalMean = new List<Double>[Constants.NumberOfPaths]; // input value for moving average (e.g. 200 values)
|
|
private List<Double> Processing8HitsMean = new List<Double>(); // input value for mean calculation. Contains eight values and is cleared afterwards
|
|
private List<Double>[] Processing8HitsTotalMean = new List<Double>[Constants.NumberOfPaths]; // input value for moving average (e.g. 200 values)
|
|
#endregion
|
|
#region Pulsewidth/ amplitude values ("OTHERS")
|
|
UInt16[] TelegramCounterOthersMean = new UInt16[Constants.NumberOfPaths] { 0, 0, 0 };
|
|
private List<Double>[] ProcessingPulsewidthUpMean = new List<Double>[Constants.NumberOfPaths];
|
|
private List<Double>[] ProcessingPulsewidthDownMean = new List<Double>[Constants.NumberOfPaths];
|
|
private List<Double>[] ProcessingAmplitudeUpMean = new List<Double>[Constants.NumberOfPaths];
|
|
private List<Double>[] ProcessingAmplitudeDownMean = new List<Double>[Constants.NumberOfPaths];
|
|
#endregion
|
|
#region Temperature
|
|
private UInt16[] TelegramCounterTemperatureMean = new UInt16[Constants.NumberOfPaths] { 0, 0, 0 };
|
|
private List<Double>[] ProcessingTemperatureMean = new List<Double>[Constants.NumberOfPaths];
|
|
#endregion
|
|
#region Flow values
|
|
private UInt16[] TelegramCounterFlowMean = new UInt16[Constants.NumberOfPaths] { 0, 0, 0 };
|
|
private List<Double>[] ProcessingFlowMean = new List<Double>[Constants.NumberOfPaths];
|
|
#endregion
|
|
#endregion
|
|
#endregion
|
|
#region Serial port parameters
|
|
private List<Byte>[] RxStringCmd = new List<Byte>[Constants.NumberOfMeters];
|
|
private String[] RxDataBuffer = new String[Constants.NumberOfMeters];
|
|
#endregion
|
|
#region Date and time
|
|
DateTime thisDay = DateTime.Today;
|
|
#endregion
|
|
#endregion
|
|
#region Initializations
|
|
public GENESIS_DISPLAY_TOOL()
|
|
{
|
|
#region Initialize component
|
|
InitializeComponent();
|
|
_GENESIS_DISPLAY_TOOL = this;
|
|
#endregion
|
|
#region Initialize central data object
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
Decoded[Path] = DecodedDataHelper.getDefaultDecodedData();
|
|
}
|
|
#endregion
|
|
#region Inititialize data lists
|
|
for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
ProcessingTofUpMean[Path] = new List<List<Double>>();
|
|
ProcessingTofDownMean[Path] = new List<List<Double>>();
|
|
ProcessingDifTofMean[Path] = new List<List<Double>>();
|
|
Processing3HitsTotalMean[Path] = new List<Double>();
|
|
Processing8HitsTotalMean[Path] = new List<Double>();
|
|
ProcessingFlowMean[Path] = new List<Double>();
|
|
ProcessingStdDeviation[Path] = new List<List<Double>>();
|
|
|
|
ParamsStdDev[Path] = new zedGraphParameters();
|
|
ProcessingAmplitudeUpMean[Path] = new List<Double>();
|
|
ProcessingTemperatureMean[Path] = new List<Double>();
|
|
ProcessingAmplitudeDownMean[Path] = new List<Double>();
|
|
ProcessingPulsewidthUpMean[Path] = new List<Double>();
|
|
ProcessingPulsewidthDownMean[Path] = new List<Double>();
|
|
Processing3HitsStdDeviation[Path] = new List<Double>();
|
|
Processing8HitsStdDeviation[Path] = new List<Double>();
|
|
}
|
|
for (UInt16 Hit = 0; Hit < 8; Hit++)
|
|
{
|
|
#region Mean values TOF, DIF-TOFs, Std.-Dev.
|
|
for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
ProcessingTofUpMean[Path].Add(new List<Double>());
|
|
ProcessingTofDownMean[Path].Add(new List<Double>());
|
|
ProcessingDifTofMean[Path].Add(new List<Double>());
|
|
ProcessingStdDeviation[Path].Add(new List<Double>());
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region Initialize graph lists
|
|
for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
for (UInt16 Hit = 0; Hit < 10; Hit++)
|
|
{
|
|
GraphListStdDevWindow[Path, Hit] = new PointPairList();
|
|
GraphListStdDevTotal[Path, Hit] = new List<PointPairList>();
|
|
GraphListStdDevTotal[Path, Hit].Add(new PointPairList());
|
|
}
|
|
|
|
GraphListMainWindow[Path] = new PointPairList();
|
|
GraphListMainTotal[Path] = new List<PointPairList>();
|
|
GraphListMainTotal[Path].Add(new PointPairList());
|
|
|
|
}
|
|
#endregion
|
|
#region Initialize serial data list
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
RxStringCmd[Meter] = new List<Byte>();
|
|
#endregion
|
|
GlobalMeterBatch = new MeterBatch();
|
|
}
|
|
#endregion
|
|
#region Control elements
|
|
#region Form1 elements
|
|
private void btn_Form1_StartLogging_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean StartRawLogging = false;
|
|
Boolean StartCsvLogging = false;
|
|
String Filename = String.Empty;
|
|
String DateTimeString = DateTime.Now.ToString(Formats.CsvFileDateTimeString);
|
|
String SaveDataPathCsv0 = String.Empty;
|
|
String SaveDataPathCsv1 = String.Empty;
|
|
String SaveDataPathCsv2 = String.Empty;
|
|
String Where = "0";
|
|
Boolean RawDialogOK = false;
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
if (cB_Form1LogRawDataEn.Checked)
|
|
{
|
|
#region Parameter query check
|
|
if (cB_Form1IncludeGp30Settings.Checked)
|
|
{
|
|
Where = "1"; // For forensic
|
|
|
|
WaitForBackgroundWorkers();
|
|
if ((l_GetFirstLevelUpPath0Meter1.Text.Contains("-")) || (l_GetFirstLevelUpPath1Meter1.Text.Contains("-")) || (l_GetFirstLevelUpPath2Meter1.Text.Contains("-")) ||
|
|
(l_GetFirstLevelDownPath0Meter1.Text.Contains("-")) || (l_GetFirstLevelDownPath1Meter1.Text.Contains("-")) || (l_GetFirstLevelDownPath2Meter1.Text.Contains("-")) ||
|
|
(l_Gp30GetAmplitudeMeter1.Text.Contains("-")) || (l_Gp30GetNumberOfPulsesMeter1.Text.Contains("-")) || (l_Gp30GetStartHitMeter1.Text.Contains("-")))
|
|
{
|
|
MessageBox.Show("Perform parameter readout or deselect\n 'Include GP30 Settings'-option", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
return;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Raw file dialog and save
|
|
|
|
if (cB_Form1LogRawDataEn.Checked)
|
|
{
|
|
Where = "2"; // for forensic
|
|
|
|
#region Raw file dialog
|
|
WaitForBackgroundWorkers();
|
|
RawDialogOK = Files.SaveFiledialogTxt("RAW", out SaveDataPathRaw, DefaultLogDirectory);
|
|
#endregion
|
|
#region Save to file
|
|
if (RawDialogOK)
|
|
{
|
|
Where = "3"; // for forensic
|
|
|
|
#region Set default directory
|
|
DefaultLogDirectory = Path.GetDirectoryName(SaveDataPathRaw);
|
|
#endregion
|
|
#region Create empty file
|
|
WaitForBackgroundWorkers();
|
|
DataToLog[Constants.Meter1] = String.Empty;
|
|
using (StreamWriter sw = File.CreateText(@SaveDataPathRaw)) { };
|
|
#endregion
|
|
#region Add header
|
|
if (cB_Form1IncludeGp30Settings.Checked)
|
|
{
|
|
WaitForBackgroundWorkers();
|
|
String HeaderText = $"H First hit up PATH1= {l_GetFirstLevelUpPath0Meter1.Text}\r\nFirst hit up PATH2= {l_GetFirstLevelUpPath1Meter1.Text}\r\nH First hit up PATH3= {l_GetFirstLevelUpPath2Meter1.Text}\r\nH First hit down PATH1= {l_GetFirstLevelDownPath0Meter1.Text}\r\nH First hit down PATH2= {l_GetFirstLevelDownPath1Meter1.Text}\r\nH First hit down PATH3= {l_GetFirstLevelDownPath2Meter1.Text}\r\nH Number of bursts= {l_Gp30GetNumberOfPulsesMeter1.Text}\r\nH Starthit= {l_Gp30GetStartHitMeter1.Text}\r\nH Amplitude= {l_Gp30GetAmplitudeMeter1.Text}\r\nH Samplerate= {l_Gp30GetSamplerateMeter1.Text}\r\n";
|
|
WaitForBackgroundWorkers();
|
|
gB_DecodedData_CsvLogging.Enabled = false;
|
|
gB_RawDataControl.Enabled = false;
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathRaw))
|
|
{
|
|
sw.Write(HeaderText);
|
|
}
|
|
}
|
|
#endregion
|
|
#region Set log control elements
|
|
gB_Form1Logging.Enabled = true;
|
|
cB_Form1IncludeGp30Settings.Enabled = false;
|
|
cB_Form1LogRawDataEn.Enabled = false;
|
|
cB_Form1UseSplitcounter.Enabled = false;
|
|
if (!cB_Form1UseSplitcounter.Checked)
|
|
{
|
|
l_Form1GenerateNewFile.Enabled = false;
|
|
l_Form1Splitcounter.Enabled = false;
|
|
}
|
|
btn_Form1StartLogging.Enabled = false;
|
|
btn_Form1StopLogging.Enabled = true;
|
|
gB_DecodedData_CsvLogging.Enabled = false;
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = false; //Checkbox for on tab 'tab_SerialConfig" to switch to normal logging
|
|
#endregion
|
|
#region Set default tab
|
|
WaitForBackgroundWorkers();
|
|
|
|
if ((tab_Maintab.SelectedTab == tab_SerialConfig) ||
|
|
(tab_Maintab.SelectedTab == tab_About) ||
|
|
(tab_Maintab.SelectedTab == tab_Report) ||
|
|
(tab_Maintab.SelectedTab == tab_Settings))
|
|
tab_Maintab.SelectedTab = tab_RawData;
|
|
#endregion
|
|
#region Set flags
|
|
StartRawLogging = true;
|
|
#endregion
|
|
}
|
|
#endregion
|
|
}
|
|
else
|
|
StartRawLogging = false;
|
|
|
|
|
|
#endregion;
|
|
#region Set flags
|
|
RawLoggingSingleMeterEnable = StartRawLogging;
|
|
LoggingCsvEn = StartCsvLogging;
|
|
|
|
if (RawLoggingSingleMeterEnable)
|
|
{
|
|
this.Invoke(new EventHandler(FileSplitter));
|
|
}
|
|
if (LoggingCsvEn)
|
|
{
|
|
this.Invoke(new EventHandler(FileSplitterCsv));
|
|
}
|
|
#endregion
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show("No data logging option selected", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_Form1_StartLogging_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", Where);
|
|
MessageBox.Show("Logging error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
gB_DecodedData_CsvLogging.Enabled = true;
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
|
|
|
|
private void btn_Form1_StopLogging_Click(object sender, EventArgs e)
|
|
{
|
|
#region Set log control elements
|
|
gB_Form1Logging.Enabled = true;
|
|
cB_Form1LogRawDataEn.Enabled = true;
|
|
cB_Form1UseSplitcounter.Enabled = true;
|
|
l_Form1GenerateNewFile.Enabled = true;
|
|
l_Form1Splitcounter.Enabled = true;
|
|
cB_Form1IncludeGp30Settings.Enabled = true;
|
|
btn_Form1StartLogging.Enabled = true;
|
|
btn_Form1StopLogging.Enabled = false;
|
|
if ((!cB_StdDevEnable.Checked) && (!cB_MeanValuesEnable.Checked)) // groupbox for CSV conversion
|
|
gB_DecodedData_CsvLogging.Enabled = true;
|
|
// cB_SerialConfigMassLoggingEn.Enabled = true; //Checkbox for on tab 'tab_SerialConfig" to switch to mass logging
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = true; //Checkbox for on tab 'tab_SerialConfig" to switch to normal logging
|
|
gB_RawDataControl.Enabled = true;
|
|
#endregion
|
|
#region Stop all logging
|
|
Boolean LogRestSingleLogging = RawLoggingSingleMeterEnable;
|
|
Boolean CsvLogRestSingleLogging = LoggingCsvEn;
|
|
LoggingCsvEn = false;
|
|
RawLoggingSingleMeterEnable = false;
|
|
#endregion
|
|
#region Write raw data to file
|
|
if (LogRestSingleLogging)
|
|
{
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathRaw))
|
|
sw.Write(DataToLog[Constants.Meter1]);
|
|
}
|
|
#endregion
|
|
#region CsvLogging
|
|
if (CsvLogRestSingleLogging)
|
|
{
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathCsv + "1.csv"))
|
|
sw.Write(CsvDataToLog[Constants.PATH0]);
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathCsv + "2.csv"))
|
|
sw.Write(CsvDataToLog[Constants.PATH1]);
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathCsv + "3.csv"))
|
|
sw.Write(CsvDataToLog[Constants.PATH2]);
|
|
}
|
|
#endregion
|
|
#region Reset data
|
|
CsvIndexValue[Constants.PATH0] = 0;
|
|
CsvIndexValue[Constants.PATH1] = 0;
|
|
CsvIndexValue[Constants.PATH2] = 0;
|
|
DataToLog[Constants.Meter1] = String.Empty;
|
|
CsvDataToLog[Constants.PATH0] = String.Empty;
|
|
CsvDataToLog[Constants.PATH1] = String.Empty;
|
|
CsvDataToLog[Constants.PATH2] = String.Empty;
|
|
#endregion
|
|
#region Reset disabled control elements
|
|
// gB_DecodedData_CsvLogging.Enabled = true;
|
|
#endregion
|
|
}
|
|
|
|
private void Form1_FormOpening(Object sender, EventArgs e)
|
|
{
|
|
CultureInfo Culture = GetGlobalCulture();
|
|
|
|
CommandInterface1.Init(Constants.Meter1, serialPortCmdMeter1, Culture);
|
|
CommandInterface2.Init(Constants.Meter2, serialPortCmdMeter2, Culture);
|
|
CommandInterface3.Init(Constants.Meter3, serialPortCmdMeter3, Culture);
|
|
#region Get serial ports
|
|
String[] ListOfComPorts = GetReadSettings.PortNames();
|
|
for (UInt16 i = 0; i < ListOfComPorts.Count(); i++)
|
|
{
|
|
lB_SerialCfg_CmdChannel.Items.Add(ListOfComPorts[i]);
|
|
lB_SerialCfg_DataComSelect.Items.Add(ListOfComPorts[i]);
|
|
lB_SerialCfgMass_CmdMeter1ComSelect.Items.Add(ListOfComPorts[i]);
|
|
lB_SerialCfgMass_CmdMeter2ComSelect.Items.Add(ListOfComPorts[i]);
|
|
lB_SerialCfgMass_CmdMeter3ComSelect.Items.Add(ListOfComPorts[i]);
|
|
lB_SerialCfgMass_DataMeter1ComSelect.Items.Add(ListOfComPorts[i]);
|
|
lB_SerialCfgMass_DataMeter2ComSelect.Items.Add(ListOfComPorts[i]);
|
|
lB_SerialCfgMass_DataMeter3ComSelect.Items.Add(ListOfComPorts[i]);
|
|
}
|
|
#endregion
|
|
#region Default initializations
|
|
Decoded[Constants.PATH0].Mode = Constants.CsvDefaultModeString; // -- Has to be clearified, how to fill with data
|
|
Decoded[Constants.PATH1].Mode = Constants.CsvDefaultModeString; // -- Has to be clearified, how to fill with data
|
|
Decoded[Constants.PATH2].Mode = Constants.CsvDefaultModeString; // -- Has to be clearified, how to fill with data
|
|
#endregion
|
|
#region Set default culture
|
|
CultureInfo culture = CultureInfo.CreateSpecificCulture("en-US");
|
|
CultureInfo.DefaultThreadCurrentCulture = culture;
|
|
CultureInfo.DefaultThreadCurrentUICulture = culture;
|
|
#endregion
|
|
#region Log control flags
|
|
LoggingCsvEn = false;
|
|
RawLoggingSingleMeterEnable = false;
|
|
#endregion
|
|
#region Log control elements init
|
|
gB_Form1Logging.Enabled = false;
|
|
cB_Form1UseSplitcounter.Enabled = true;
|
|
btn_Form1StopLogging.Enabled = false;
|
|
#endregion
|
|
#region Form1 control elements
|
|
gB_SideParameters.Enabled = false;
|
|
gB_SidePercentage.Enabled = false;
|
|
#endregion
|
|
#region Serial config control elements
|
|
btn_SerialCfg_CmdOpen.Enabled = true;
|
|
btn_SerialCfg_CmdClose.Enabled = false;
|
|
btn_SerialCfg_DataOpen.Enabled = true;
|
|
btn_SerialCfg_DataClose.Enabled = false;
|
|
#endregion
|
|
#region Mean values control elements
|
|
pB_StdDeviation.Maximum = (Int32)nUD_SettingsStdDev.Value;
|
|
#endregion
|
|
#region GP30 control elements
|
|
l_SetFirstLevelUpPath0Meter1.Text = ((Double)nUD_SetFirstLevelUpPath0Meter1.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
l_SetFirstLevelUpPath0Meter2.Text = ((Double)nUD_SetFirstLevelUpPath0Meter2.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
l_SetFirstLevelUpPath0Meter3.Text = ((Double)nUD_SetFirstLevelUpPath0Meter3.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
|
|
l_SetFirstLevelUpPath1Meter1.Text = ((Double)nUD_SetFirstLevelUpPath1Meter1.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
l_SetFirstLevelUpPath1Meter2.Text = ((Double)nUD_SetFirstLevelUpPath1Meter2.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
l_SetFirstLevelUpPath1Meter3.Text = ((Double)nUD_SetFirstLevelUpPath1Meter3.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
|
|
l_SetFirstLevelUpPath2Meter1.Text = ((Double)nUD_SetFirstLevelUpPath2Meter1.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
l_SetFirstLevelUpPath2Meter2.Text = ((Double)nUD_SetFirstLevelUpPath2Meter2.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
l_SetFirstLevelUpPath2Meter3.Text = ((Double)nUD_SetFirstLevelUpPath2Meter3.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
|
|
l_SetFirstLevelDownPath0Meter1.Text = ((Double)nUD_SetFirstLevelUpPath0Meter1.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
l_SetFirstLevelDownPath0Meter2.Text = ((Double)nUD_SetFirstLevelUpPath0Meter2.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
l_SetFirstLevelDownPath0Meter3.Text = ((Double)nUD_SetFirstLevelUpPath0Meter3.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
|
|
l_SetFirstLevelDownPath1Meter1.Text = ((Double)nUD_SetFirstLevelUpPath1Meter1.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
l_SetFirstLevelDownPath1Meter2.Text = ((Double)nUD_SetFirstLevelUpPath1Meter2.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
l_SetFirstLevelDownPath1Meter3.Text = ((Double)nUD_SetFirstLevelUpPath1Meter3.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
|
|
l_SetFirstLevelDownPath2Meter1.Text = ((Double)nUD_SetFirstLevelUpPath2Meter1.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
l_SetFirstLevelDownPath2Meter2.Text = ((Double)nUD_SetFirstLevelUpPath2Meter2.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
l_SetFirstLevelDownPath2Meter3.Text = ((Double)nUD_SetFirstLevelUpPath2Meter3.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture()) + Units.FirstHitLevelVoltage;
|
|
#endregion
|
|
#region Get serial config from file
|
|
MassLogging = false;
|
|
cB_SerialConfigMassLoggingEn.Checked = MassLogging;
|
|
cB_SerialConfigMassMassLoggingEn.Checked = MassLogging;
|
|
#endregion
|
|
#region Json control elements
|
|
rTB_JsonWrite.MaxLength = GP30Parameters.TXDataMaxlength;
|
|
#endregion
|
|
#region Graphs init
|
|
InitMainGraph(lB_Graph_SelectGraph.Text, (Double)nUD_SettingsXMainGraph.Value, (Int32)nUD_SettingsStdDev.Value, (Int32)nUD_SettingsMean.Value, cB_MultihitOverallAvgEn.Checked);
|
|
InitStdDevGraph((Double)nUD_SettingsXrangeStdDevGraph.Value, cB_ReportStdDevPath0.Checked, cB_ReportStdDevPath1.Checked, cB_ReportStdDevPath2.Checked, (Int32)nUD_SettingsStdDev.Value, (Int32)nUD_SettingsMean.Value, cB_MultihitOverallAvgEn.Checked);
|
|
#endregion
|
|
#region Get date
|
|
rTB_ReportEnterDate.Text = DateTime.Now.ToString(Formats.ReportDateTimeTitleString, GetGlobalCulture());
|
|
#endregion
|
|
#region Set default tab
|
|
tab_Maintab.TabPages.Remove(tab_DataDecoding);
|
|
tab_Maintab.TabPages.Remove(tab_MeanValues);
|
|
tab_Maintab.TabPages.Remove(tab_StdDev);
|
|
if (MassLogging)
|
|
{
|
|
#region Mass logging
|
|
gB_ElapsedCalcCycles.Enabled = false;
|
|
tab_Maintab.TabPages.Remove(tab_Graph);
|
|
tab_Maintab.TabPages.Remove(tab_StdDev);
|
|
tab_Maintab.TabPages.Remove(tab_DataDecoding);
|
|
tab_Maintab.TabPages.Remove(tab_DataDecoding2);
|
|
tab_Maintab.TabPages.Remove(tab_RawData);
|
|
tab_Maintab.TabPages.Remove(tab_MeanValues);
|
|
tab_Maintab.TabPages.Remove(tab_SerialConfig);
|
|
tab_Maintab.TabPages.Remove(tab_Report);
|
|
tab_GP30SettingsMeter1.Text = "GP30 settings METER1";
|
|
gB_JsonSelectMeter.Visible = true; // radio buttons for meter select
|
|
gB_Form1Logging.Visible = false;
|
|
tab_Maintab.SelectedTab = tab_SerialConfigMass;
|
|
#endregion
|
|
}
|
|
else
|
|
{
|
|
#region Single logging
|
|
tab_Maintab.TabPages.Remove(tab_SerialConfigMass);
|
|
tab_Maintab.TabPages.Remove(tab_Logging);
|
|
tab_Maintab.TabPages.Remove(tab_Gp30SettingsMeter2);
|
|
tab_Maintab.TabPages.Remove(tab_Gp30SettingsMeter3);
|
|
gB_JsonSelectMeter.Visible = false; // radio buttons for meter select
|
|
tab_Maintab.SelectedTab = tab_SerialConfig;
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region Tooltips
|
|
#region Definitions and initializations
|
|
|
|
ToolTip TtToolTip1 = new ToolTip();
|
|
ToolTip TtSerialConfig = new ToolTip();
|
|
#endregion
|
|
#region Tool tip implementation
|
|
#region Form1 Tool tips
|
|
TtToolTip1.SetToolTip(this.pB_Logo, "www.sensus.com");
|
|
TtToolTip1.SetToolTip(this.cB_Form1LogRawDataEn, "Select to log raw data to text file");
|
|
TtToolTip1.SetToolTip(this.nUD_Settings_RxDataAutoclear, "Rx Data Window will be cleared after the adjusted number\nof values. When set to high the application might be slow.");
|
|
TtToolTip1.SetToolTip(this.btn_Form1StartLogging, "Select checkbox 'Raw data logging'or\n'CSV data logging' to start logging.");
|
|
TtToolTip1.SetToolTip(this.btn_Form1StopLogging, "Stop Logging");
|
|
#endregion
|
|
#region Raw data tool tips
|
|
TtToolTip1.SetToolTip(this.btn_RawData_Clear, "Clear Rx data window");
|
|
TtToolTip1.SetToolTip(this.btn_RawData_Save, "Save Rx data window to text file");
|
|
TtToolTip1.SetToolTip(this.btn_RawData_Open, "Open text file");
|
|
TtToolTip1.SetToolTip(this.rtB_RawData_RxData, "ATTENTION:\nRx data window not suitable for long term measurements!\nWindow will be cleared periodically!Setup at tab 'Settings'.");
|
|
#endregion
|
|
#region Serial configuration
|
|
TtSerialConfig.SetToolTip(this.btn_SerialCfg_CmdOpen, "Open/ Enable serial port");
|
|
TtSerialConfig.SetToolTip(this.btn_SerialCfgMass_CmdMeter1Open, "Open/ Enable serial port");
|
|
TtSerialConfig.SetToolTip(this.btn_SerialCfgMass_CmdMeter2Open, "Open/ Enable serial port");
|
|
TtSerialConfig.SetToolTip(this.btn_SerialCfgMass_CmdMeter3Open, "Open/ Enable serial port");
|
|
TtSerialConfig.SetToolTip(this.btn_SerialCfgMass_DataMeter1Open, "Open/ Enable serial port");
|
|
TtSerialConfig.SetToolTip(this.btn_SerialCfgMass_DataMeter2Open, "Open/ Enable serial port");
|
|
TtSerialConfig.SetToolTip(this.btn_SerialCfgMass_DataMeter3Open, "Open/ Enable serial port");
|
|
|
|
TtSerialConfig.SetToolTip(this.btn_SerialCfgMass_CmdMeter1Inhibit, "Inhibit serial port. Restart\napplication to select different\nport settings.");
|
|
TtSerialConfig.SetToolTip(this.btn_SerialCfgMass_CmdMeter2Inhibit, "Inhibit serial port. Restart\napplication to select different\nport settings.");
|
|
TtSerialConfig.SetToolTip(this.btn_SerialCfgMass_CmdMeter3Inhibit, "Inhibit serial port. Restart\napplication to select different\nport settings.");
|
|
TtSerialConfig.SetToolTip(this.btn_SerialCfgMass_DataMeter1Inhibit, "Inhibit serial port. Restart\napplication to select different\nport settings.");
|
|
TtSerialConfig.SetToolTip(this.btn_SerialCfgMass_DataMeter2Inhibit, "Inhibit serial port. Restart\napplication to select different\nport settings.");
|
|
TtSerialConfig.SetToolTip(this.btn_SerialCfgMass_DataMeter3Inhibit, "Inhibit serial port. Restart\napplication to select different\nport settings.");
|
|
|
|
#endregion
|
|
#region Decoded data tool tips
|
|
TtToolTip1.SetToolTip(this.btn_DecodedData_CsvLogging_Convert, "A raw data file can be converted Int32o\nthree CSV-files according EFM32-format.\nSuspended if CSV-logging, Std.-Deviation-\nor Mean calculation is running");
|
|
TtToolTip1.SetToolTip(this.btn_DataDecodingCsvExport, "Export displayed data to CSV file");
|
|
TtToolTip1.SetToolTip(this.btn_ClearComment, "Clear comment field");
|
|
#endregion
|
|
#region Graph tool tips
|
|
TtToolTip1.SetToolTip(this.btn_Graph_SaveDiagram, "Save graph pane to image file");
|
|
TtToolTip1.SetToolTip(this.gB_GraphOptionsPathsEn, "Select paths to be displayed");
|
|
TtToolTip1.SetToolTip(this.cB_GraphOptionEnPath0, "Select paths to be displayed");
|
|
TtToolTip1.SetToolTip(this.cB_GraphOptionEnPath1, "Select paths to be displayed");
|
|
TtToolTip1.SetToolTip(this.cB_GraphOptionEnPath2, "Select paths to be displayed");
|
|
TtToolTip1.SetToolTip(this.lB_Graph_SelectGraph, "Select parameter to be displayed");
|
|
TtToolTip1.SetToolTip(this.cB_GraphReset, "Graph enable.\nOlder values are RESET");
|
|
TtToolTip1.SetToolTip(this.nUD_SettingsXMainGraph, "Number of values for X-Axis");
|
|
TtToolTip1.SetToolTip(this.nUD_MaingraphNomVal, "The expected flow value flowing through the meter\nGraph is showing percental deviation from this value\nValue must NOT be zero!");
|
|
#endregion
|
|
#region Mean values tool tips
|
|
TtToolTip1.SetToolTip(this.pB_Mean, "Percentage of buffered data required to calculate the mean values");
|
|
TtToolTip1.SetToolTip(this.cB_MeanValuesEnable, "Mean value calculation enable.\nOlder values are RESET");
|
|
TtToolTip1.SetToolTip(this.nUD_SettingsMean, "Mean value calculation:\nNumber of values buffered for calculation");
|
|
TtToolTip1.SetToolTip(this.btn_MeanValuesCsvExport, "Export displayed data to CSV file");
|
|
TtToolTip1.SetToolTip(this.cB_MultihitOverallAvgEn, "First an average over 3/8 values is calculated.\nIf enabled an average of n values is calculated\nIf not enabled the direct value is displayed\n\nNote: Has direct influence on 3/8Hit standard deviation calculation!");
|
|
#endregion
|
|
#region Standard deviation tool tips
|
|
TtToolTip1.SetToolTip(this.pB_StdDeviation, "Percentage of buffered data required to calculate the standard deviation");
|
|
TtToolTip1.SetToolTip(this.btn_StdDevSavePath0, "Save to image file");
|
|
TtToolTip1.SetToolTip(this.btn_StdDevSavePath1, "Save to image file");
|
|
TtToolTip1.SetToolTip(this.btn_StdDevSavePath2, "Save to image file");
|
|
TtToolTip1.SetToolTip(this.cB_StdDevEnable, "Standard deviation calculation enable.\nOlder values are RESET");
|
|
TtToolTip1.SetToolTip(this.nUD_SettingsStdDev, "Standard deviation calculation:\nNumber of values buffered for calculation");
|
|
TtToolTip1.SetToolTip(this.btn_StdDeviationCsvExport, "Export displayed data to CSV file");
|
|
#endregion
|
|
#region GP30 tool tips
|
|
#region METER1
|
|
TtToolTip1.SetToolTip(this.btn_Gp30GetSerialNoMeter1, "Get serial number\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30GetStartHitMeter1, "Get start hit\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30GetAmplitudeMeter1, "Get amplitude end detection value\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30SetStartHitMeter1, "Set start hit\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30SetAmplitudeMeter1, "Set amplitude end detection value\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readNumberOfTXBurstsMeter1, "Get start number of TX-bursts\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30SetNumberOfTXBurstsMeter1, "Set start number of TX-bursts\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30getMeterSizeMeter1, "Get meter size 0..9");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30setMeterSizeMeter1, "Set meter size 0..9");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30getLedModeMeter1, "Get meter LED mode:\n0 = Off\n1 = raw mode\n2 = Something strange\n3 = calibration");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30setLedModeMeter1, "Set meter LED mode:\n0 = Off\n1 = raw mode\n2 = Something strange\n3 = calibration");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30getForwardArrowMeter1, "Get forward arrow:\n1 = Left to right\n2 = Right to left");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30setForwardArrowMeter1, "Set forward arrow:\n1 = Left to right\n2 = Right to left");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelUpPath0Meter1, "Get first hit up value of PATH0\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelUpPath1Meter1, "Get first hit up value of PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelUpPath2Meter1, "Get first hit up value of PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelDownPath0Meter1, "Get first hit down value of PATH0\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelDownPath1Meter1, "Get first hit down value of PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelDownPath2Meter1, "Get first hit down value of PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30GetSamplerateMeter1, "Get sample rate (0..6)\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30SetSamplerateMeter1, "Set sample rate (0..6)\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelUpPath0Meter1, "Set first hit up value of PATH0\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelUpPath1Meter1, "Set first hit up value of PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelUpPath2Meter1, "Set first hit up value of PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelDownPath0Meter1, "Set first hit down value of PATH0\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelDownPath1Meter1, "Set first hit down value of PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelDownPath2Meter1, "Set first hit down value of PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SideSetStartHit, "Set start hit\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SideSetAmplitude, "Set amplitude end detection value\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SideSetNumberOfTXBursts, "Set start number of TX-bursts\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SidePercentagePath0, "Set first hit up value of PATH0\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SidePercentagePath1, "Set first hit up value of PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SidePercentagePath2, "Set first hit up value of PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readCalFactorPath0Meter1, "Get calibration factor PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeCalFactorPath0Meter1, "Set calibration factor PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readCalFactorPath1Meter1, "Get calibration factor PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeCalFactorPath1Meter1, "Set calibration factor PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readCalFactorPath2Meter1, "Get calibration factor PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeCalFactorPath2Meter1, "Set calibration factor PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readZeroOffsetPath0Meter1, "Get zero offset PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeZeroOffsetPath0Meter1, "Set zero offset PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readZeroOffsetPath1Meter1, "Get zero offset PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeZeroOffsetPath1Meter1, "Set zero offset PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readZeroOffsetPath2Meter1, "Get zero offset PATH3\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeZeroOffsetPath2Meter1, "Set zero offset PATH3\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_CommandChannelVoltageMeter1, "Get voltage\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_CommandChannelClearMeter1, "Clear windows and labels");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30accuResetMeter1, "Accumulator reset");
|
|
#endregion
|
|
#region METER2
|
|
TtToolTip1.SetToolTip(this.btn_Gp30GetSerialNoMeter2, "Get serial number\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30GetStartHitMeter2, "Get start hit\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30GetAmplitudeMeter2, "Get amplitude end detection value\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30SetStartHitMeter2, "Set start hit\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30SetAmplitudeMeter2, "Set amplitude end detection value\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30GetNumberOfTXBurstsMeter2, "Get start number of TX-bursts\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30SetNumberOfTXBurstsMeter2, "Set start number of TX-bursts\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30getMeterSizeMeter2, "Get meter size 0..9");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30setMeterSizeMeter2, "Set meter size 0..9");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30getLedModeMeter2, "Get meter LED mode:\n0 = Off\n1 = d-protocol\n2 = Something strange\n3 = e-protocol");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30setLedModeMeter2, "Set meter LED mode:\n0 = Off\n1 = d-protocol\n2 = Something strange\n3 = e-protocol");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30getForwardArrowMeter2, "Get forward arrow:\n1 = Left to right\n2 = Right to left");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30setForwardArrowMeter2, "Set forward arrow:\n1 = Left to right\n2 = Right to left");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelUpPath0Meter2, "Get first hit up value of PATH0\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelUpPath1Meter2, "Get first hit up value of PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelUpPath2Meter2, "Get first hit up value of PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelDownPath0Meter2, "Get first hit down value of PATH0\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelDownPath1Meter2, "Get first hit down value of PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelDownPath2Meter2, "Get first hit down value of PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30GetSamplerateMeter2, "Get sample rate (0..6)\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30SetSamplerateMeter2, "Set sample rate (0..6)\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelUpPath0Meter2, "Set first hit up value of PATH0\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelUpPath1Meter2, "Set first hit up value of PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelUpPath2Meter2, "Set first hit up value of PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelDownPath0Meter2, "Set first hit down value of PATH0\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelDownPath1Meter2, "Set first hit down value of PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelDownPath2Meter2, "Set first hit down value of PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readCalFactorPath0Meter2, "Get calibration factor PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeCalFactorPath0Meter2, "Set calibration factor PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readCalFactorPath1Meter2, "Get calibration factor PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeCalFactorPath1Meter2, "Set calibration factor PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readCalFactorPath2Meter2, "Get calibration factor PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeCalFactorPath2Meter2, "Set calibration factor PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readZeroOffsetPath0Meter2, "Get zero offset PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeZeroOffsetPath0Meter2, "Set zero offset PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readZeroOffsetPath1Meter2, "Get zero offset PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeZeroOffsetPath1Meter2, "Set zero offset PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readZeroOffsetPath2Meter2, "Get zero offset PATH3\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeZeroOffsetPath2Meter2, "Set zero offset PATH3\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_CommandChannelVoltageMeter2, "Get voltage\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_CommandChannelClearMeter2, "Clear windows and labels");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30accuResetMeter2, "Accumulator reset");
|
|
#endregion
|
|
#region Meter3
|
|
TtToolTip1.SetToolTip(this.btn_Gp30GetSerialNoMeter3, "Get serial number\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30GetStartHitMeter3, "Get start hit\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30GetAmplitudeMeter3, "Get amplitude end detection value\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30SetStartHitMeter3, "Set start hit\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30SetAmplitudeMeter3, "Set amplitude end detection value\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30GetNumberOfTXBurstsMeter3, "Get start number of TX-bursts\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30SetNumberOfTXBurstsMeter3, "Set start number of TX-bursts\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30getMeterSizeMeter3, "Get meter size 0..9");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30setMeterSizeMeter3, "Set meter size 0..9");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30getLedModeMeter3, "Get meter LED mode:\n0 = Off\n1 = d-protocol\n2 = Something strange\n3 = e-protocol");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30setLedModeMeter3, "Set meter LED mode:\n0 = Off\n1 = d-protocol\n2 = Something strange\n3 = e-protocol");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30getForwardArrowMeter3, "Get forward arrow:\n1 = Left to right\n2 = Right to left");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30setForwardArrowMeter3, "Set forward arrow:\n1 = Left to right\n2 = Right to left");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelUpPath0Meter3, "Get first hit up value of PATH0\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelUpPath1Meter3, "Get first hit up value of PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelUpPath2Meter3, "Get first hit up value of PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelDownPath0Meter3, "Get first hit down value of PATH0\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelDownPath1Meter3, "Get first hit down value of PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_GetFirstLevelDownPath2Meter3, "Get first hit down value of PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30GetSamplerateMeter3, "Get sample rate (0..6)\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30SetSamplerateMeter3, "Set sample rate (0..6)\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelUpPath0Meter3, "Set first hit up value of PATH0\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelUpPath1Meter3, "Set first hit up value of PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelUpPath2Meter3, "Set first hit up value of PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelDownPath0Meter3, "Set first hit down value of PATH0\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelDownPath1Meter3, "Set first hit down value of PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_SetFirstLevelDownPath2Meter3, "Set first hit down value of PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readCalFactorPath0Meter3, "Get calibration factor PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeCalFactorPath0Meter3, "Set calibration factor PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readCalFactorPath1Meter3, "Get calibration factor PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeCalFactorPath1Meter3, "Set calibration factor PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readCalFactorPath2Meter3, "Get calibration factor PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeCalFactorPath2Meter3, "Set calibration factor PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readZeroOffsetPath0Meter3, "Get zero offset PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeZeroOffsetPath0Meter3, "Set zero offset PATH1\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readZeroOffsetPath1Meter3, "Get zero offset PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeZeroOffsetPath1Meter3, "Set zero offset PATH2\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30readZeroOffsetPath2Meter3, "Get zero offset PATH3\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30writeZeroOffsetPath2Meter3, "Set zero offset PATH3\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_CommandChannelVoltageMeter3, "Get voltage\nLOGIN required");
|
|
TtToolTip1.SetToolTip(this.btn_CommandChannelClearMeter3, "Clear windows and labels");
|
|
TtToolTip1.SetToolTip(this.btn_Gp30accuResetMeter3, "Accumulator reset");
|
|
#endregion
|
|
#endregion
|
|
#region Json tooltips
|
|
TtToolTip1.SetToolTip(this.btn_JsonWrite, "Write data to selected register");
|
|
TtToolTip1.SetToolTip(this.btn_JsonRead, "Read data from selected register");
|
|
TtToolTip1.SetToolTip(this.btn_JsonUpdate, "Update from last JSON-file path");
|
|
TtToolTip1.SetToolTip(this.btn_JsonClearWindow, "Clear windows and labels");
|
|
#endregion
|
|
#region Raw data tool tips
|
|
//TtToolTip1.SetToolTip(this.cB_RawPath0, "Enable/ disable raw data display of PATH1\n\nATTENTION:\nDisabled paths will NOT be logged!\n\n");
|
|
//TtToolTip1.SetToolTip(this.cB_RawPath1, "Enable/ disable raw data display of PATH2\n\nATTENTION:\nDisabled paths will NOT be logged!\n\n");
|
|
//TtToolTip1.SetToolTip(this.cB_RawPath2, "Enable/ disable raw data display of PATH3\n\nATTENTION:\nDisabled paths will NOT be logged!\n\n");
|
|
#endregion
|
|
#region Settings tool tips
|
|
TtToolTip1.SetToolTip(this.btn_ElapsedToCsv, "Export displayed data to CSV file");
|
|
#endregion
|
|
#region Serial settings
|
|
TtToolTip1.SetToolTip(this.gB_MassLogging, "Disabled when calculations or graphs are running");
|
|
#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
|
|
}
|
|
|
|
public static GENESIS_DISPLAY_TOOL _GENESIS_DISPLAY_TOOL;
|
|
|
|
private void Form1_FormClosing(Object sender, FormClosingEventArgs e)
|
|
{
|
|
// -- deactivate buttons --
|
|
btn_Form1StartLogging.Enabled = false;
|
|
btn_Form1StopLogging.Enabled = false;
|
|
|
|
|
|
// -- New style logging --
|
|
if (LoggingCsvEn)
|
|
{
|
|
LoggingCsvEn = false;
|
|
|
|
using (StreamWriter sw = File.AppendText($"@{SaveDataPathCsv}1.csv"))
|
|
sw.Write(CsvDataToLog[Constants.PATH0]);
|
|
using (StreamWriter sw = File.AppendText($"@{SaveDataPathCsv}2.csv"))
|
|
sw.Write(CsvDataToLog[Constants.PATH1]);
|
|
using (StreamWriter sw = File.AppendText($"@{SaveDataPathCsv}3.csv"))
|
|
sw.Write(CsvDataToLog[Constants.PATH2]);
|
|
}
|
|
|
|
if (RawLoggingSingleMeterEnable)
|
|
{
|
|
RawLoggingSingleMeterEnable = false;
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathRaw))
|
|
{
|
|
sw.Write(DataToLog[Constants.Meter1]);
|
|
}
|
|
DataToLog[Constants.Meter1] = String.Empty;
|
|
}
|
|
if (RawLoggingEnable[Constants.Meter1])
|
|
{
|
|
RawLoggingEnable[Constants.Meter1] = false;
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathMeter1))
|
|
sw.Write(DataToLog[Constants.Meter1]);
|
|
DataToLog[Constants.Meter1] = String.Empty;
|
|
}
|
|
if (RawLoggingEnable[Constants.Meter2])
|
|
{
|
|
RawLoggingEnable[Constants.Meter2] = false;
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathMeter2))
|
|
sw.Write(DataToLog[Constants.Meter2]);
|
|
DataToLog[Constants.Meter2] = String.Empty;
|
|
}
|
|
if (RawLoggingEnable[Constants.Meter3])
|
|
{
|
|
RawLoggingEnable[Constants.Meter3] = false;
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathMeter3))
|
|
sw.Write(DataToLog[Constants.Meter3]);
|
|
DataToLog[Constants.Meter3] = String.Empty;
|
|
}
|
|
|
|
// -- Write serial port settings to text file --
|
|
//WriteSettingsToFile(@"..\OBS_settings.txt", MassLogging);
|
|
Environment.Exit(0);
|
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
#region Raw data control elements
|
|
/// <summary>
|
|
/// Clear textbox with rx data
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void btn_RawData_Clear_Click(object sender, EventArgs e)
|
|
{
|
|
rtB_RawData_RxData.Clear();
|
|
}
|
|
|
|
/// <summary>
|
|
/// save raw data to text file
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void btn_RawData_Save_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean FileDialogOk = false;
|
|
Boolean SavingOk = false;
|
|
String Fullpath = String.Empty;
|
|
String Itemname = "raw";
|
|
#endregion
|
|
|
|
WaitForBackgroundWorkers();
|
|
FileDialogOk = Files.SaveFiledialogTxt(Itemname, out Fullpath, DefaultLogDirectory);
|
|
if (FileDialogOk)
|
|
{
|
|
#region Set default path
|
|
DefaultLogDirectory = Path.GetDirectoryName(Fullpath);
|
|
#endregion
|
|
#region Save data
|
|
WaitForBackgroundWorkers();
|
|
SavingOk = Files.SaveText(rtB_RawData_RxData.Text, Fullpath, GetGlobalCulture());
|
|
#endregion
|
|
}
|
|
|
|
if ((!SavingOk) && (FileDialogOk))
|
|
MessageBox.Show("Saving failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
|
|
/// <summary>
|
|
/// open raw data text file
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void btn_RawData_Open_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
String Fullpath = String.Empty;
|
|
String Data = String.Empty;
|
|
Boolean FileDialogOk = false;
|
|
Boolean OpeningOk = false;
|
|
#endregion
|
|
|
|
FileDialogOk = Files.OpenFileDialogText(out Fullpath, DefaultLogDirectory);
|
|
if (FileDialogOk)
|
|
{
|
|
DefaultLogDirectory = Path.GetDirectoryName(Fullpath);
|
|
OpeningOk = Files.OpenText(out Data, Fullpath, GetGlobalCulture());
|
|
}
|
|
if ((!OpeningOk) && (FileDialogOk))
|
|
MessageBox.Show("Opening failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
else
|
|
{
|
|
#region Display in rich text box
|
|
rtB_RawData_RxData.AppendText(Data);
|
|
rtB_RawData_RxData.ScrollToCaret();
|
|
#endregion
|
|
}
|
|
}
|
|
#endregion
|
|
#region Decoded data control elements
|
|
private void btn_ClearComment_Click(object sender, EventArgs e)
|
|
{
|
|
rTB_DecodedDataComment.Clear();
|
|
}
|
|
|
|
private void btn_DecodedData_CsvLogging_Convert_Click(object sender, EventArgs e)
|
|
{
|
|
gB_Form1Logging.Enabled = false;
|
|
WaitForBackgroundWorkers();
|
|
CsvLogging.Convert(Constants.NominalFrequency, ref DefaultLogDirectory);
|
|
// -- enable logging group box --
|
|
gB_Form1Logging.Enabled = true;
|
|
}
|
|
private void btn_DataDecodingCsvExport_Click(object sender, EventArgs e)
|
|
{
|
|
String Data = CsvDecodedDataPage(true);
|
|
String Fullpath = String.Empty;
|
|
Boolean FileDialogOK = false;
|
|
Boolean SavingOK = false;
|
|
|
|
WaitForBackgroundWorkers();
|
|
FileDialogOK = Files.SaveFiledialogCsv("Decoded Data", out Fullpath, DefaultCsvDirectory);
|
|
if (FileDialogOK)
|
|
{
|
|
DefaultCsvDirectory = Path.GetDirectoryName(Fullpath);
|
|
WaitForBackgroundWorkers();
|
|
SavingOK = Files.SaveText(Data, Fullpath, GetGlobalCulture());
|
|
}
|
|
|
|
if ((!SavingOK) && (FileDialogOK))
|
|
MessageBox.Show("Saving failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
#endregion
|
|
#region Report control elements
|
|
private void btn_Report_Generate_Click(object sender, EventArgs e)
|
|
{
|
|
gB_report.Enabled = false;
|
|
btn_Report_Generate.Enabled = false;
|
|
FormControl.DisableTabExceptReport(true);
|
|
GeneratePdfReport(GetGlobalCulture());
|
|
gB_report.Enabled = true;
|
|
FormControl.DisableTabExceptReport(false);
|
|
btn_Report_Generate.Enabled = true;
|
|
}
|
|
#endregion
|
|
#region Standard deviation control elements
|
|
#region Save images
|
|
private void btn_StdDev_CH0_save_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
String Itemname = "Std Deviation_PATH1";
|
|
String Fullpath = String.Empty;
|
|
Boolean FileDialogOK = false;
|
|
Boolean SavingOK = false;
|
|
#endregion
|
|
#region Everything else
|
|
WaitForBackgroundWorkers();
|
|
FileDialogOK = Files.SaveFiledialogPng(Itemname, out Fullpath, DefaultImagesDirectory);
|
|
if (FileDialogOK)
|
|
{
|
|
DefaultImagesDirectory = Path.GetDirectoryName(Fullpath);
|
|
WaitForBackgroundWorkers();
|
|
SavingOK = Files.SaveImage(zGC_StdDevPath0, Fullpath, GetGlobalCulture());
|
|
}
|
|
if ((!SavingOK) && (FileDialogOK))
|
|
MessageBox.Show("Saving failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
private void btn_StdDev_CH1_save_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
String Itemname = "Std Deviation_PATH2";
|
|
String Fullpath = String.Empty;
|
|
Boolean FileDialogOK = false;
|
|
Boolean SavingOK = false;
|
|
#endregion
|
|
#region Everything else
|
|
WaitForBackgroundWorkers();
|
|
FileDialogOK = Files.SaveFiledialogPng(Itemname, out Fullpath, DefaultImagesDirectory);
|
|
if (FileDialogOK)
|
|
{
|
|
DefaultImagesDirectory = Path.GetDirectoryName(Fullpath);
|
|
WaitForBackgroundWorkers();
|
|
SavingOK = Files.SaveImage(zGC_StdDevPath1, Fullpath, GetGlobalCulture());
|
|
}
|
|
if ((!SavingOK) && (FileDialogOK))
|
|
MessageBox.Show("Saving failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
private void btn_StdDev_CH2_save_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
String Itemname = "Std Deviation_PATH3";
|
|
String Fullpath = String.Empty;
|
|
Boolean FileDialogOK = false;
|
|
Boolean SavingOK = false;
|
|
#endregion
|
|
#region Everything else
|
|
WaitForBackgroundWorkers();
|
|
FileDialogOK = Files.SaveFiledialogPng(Itemname, out Fullpath, DefaultImagesDirectory);
|
|
if (FileDialogOK)
|
|
{
|
|
DefaultImagesDirectory = Path.GetDirectoryName(Fullpath);
|
|
WaitForBackgroundWorkers();
|
|
SavingOK = Files.SaveImage(zGC_StdDevPath2, Fullpath, GetGlobalCulture());
|
|
}
|
|
if ((!SavingOK) && (FileDialogOK))
|
|
MessageBox.Show("Saving failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region Basic control
|
|
private void cBStdDevEnable_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Int32 ClearValue = (Int32)nUD_SettingsXrangeStdDevGraph.Value;
|
|
Int32 TotalNumberOfValues = (Int32)GraphCounterDataStdDevTotal[Constants.PATH2];
|
|
Int32[] NewScaleMin = new Int32[Constants.NumberOfPaths] { 0, 0, 0 };
|
|
Int32[] NewScaleMax = new Int32[Constants.NumberOfPaths] { 0, 0, 0 };
|
|
Int32 DataIndex = 0;
|
|
Int32 PosIndex = 0;
|
|
Int32[] XScaleMin = new Int32[Constants.NumberOfPaths];
|
|
XScaleMin[Constants.PATH0] = (Int32)Math.Round(zGC_StdDevPath0.GraphPane.XAxis.Scale.Min, 0);
|
|
XScaleMin[Constants.PATH1] = (Int32)Math.Round(zGC_StdDevPath1.GraphPane.XAxis.Scale.Min, 0);
|
|
XScaleMin[Constants.PATH2] = (Int32)Math.Round(zGC_StdDevPath2.GraphPane.XAxis.Scale.Min, 0);
|
|
Int32[] XScaleMax = new Int32[Constants.NumberOfPaths];
|
|
XScaleMax[Constants.PATH0] = (Int32)Math.Round(zGC_StdDevPath0.GraphPane.XAxis.Scale.Max, 0);
|
|
XScaleMax[Constants.PATH1] = (Int32)Math.Round(zGC_StdDevPath1.GraphPane.XAxis.Scale.Max, 0);
|
|
XScaleMax[Constants.PATH2] = (Int32)Math.Round(zGC_StdDevPath2.GraphPane.XAxis.Scale.Max, 0);
|
|
#endregion
|
|
#region Everything else
|
|
if (cB_StdDevEnable.Checked)
|
|
{
|
|
#region Reset
|
|
ElapsedCounterStdDeviation = 0;
|
|
StdDeviationCalculate.Reset(ref TelegramCounterStdDeviationMultihit, ref TelegramCounterStdDeviationSingle, ref ProcessingStdDeviation, ref Processing3HitsStdDeviation, ref Processing8HitsStdDeviation);
|
|
ResetStdDevGraph((Double)nUD_SettingsXrangeStdDevGraph.Value);
|
|
InitStdDevGraph((Double)nUD_SettingsXrangeStdDevGraph.Value, cB_ReportStdDevPath0.Checked, cB_ReportStdDevPath1.Checked, cB_ReportStdDevPath2.Checked, (Int32)nUD_SettingsStdDev.Value, (Int32)nUD_SettingsMean.Value, cB_MultihitOverallAvgEn.Checked);
|
|
|
|
zGC_StdDevPath0.IsShowHScrollBar = false;
|
|
zGC_StdDevPath1.IsShowHScrollBar = false;
|
|
zGC_StdDevPath2.IsShowHScrollBar = false;
|
|
zGC_StdDevPath0.IsEnableZoom = false;
|
|
zGC_StdDevPath1.IsEnableZoom = false;
|
|
zGC_StdDevPath2.IsEnableZoom = false;
|
|
nUD_SettingsStdDev.Enabled = false;
|
|
ResetLabelsStdDeviation();
|
|
|
|
if (((cB_StdDev8CrossingsPath0.Checked) ||
|
|
(cB_StdDev8CrossingsPath1.Checked) ||
|
|
(cB_StdDev8CrossingsPath2.Checked) ||
|
|
(cB_StdDev3CrossingsPath0.Checked) ||
|
|
(cB_StdDev3CrossingsPath1.Checked) ||
|
|
(cB_StdDev3CrossingsPath2.Checked)) &&
|
|
!cB_MeanValuesEnable.Checked)
|
|
{
|
|
cB_MeanValuesEnable.Checked = true;
|
|
MessageBox.Show("Mean calculation enabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
}
|
|
#endregion
|
|
#region Button for CSV-Converting
|
|
gB_DecodedData_CsvLogging.Enabled = false;
|
|
#endregion
|
|
#region Groupbox for X-Values
|
|
gB_SettingsStdDevGraph.Enabled = false;
|
|
#endregion
|
|
#region tab_SerialConfig
|
|
cB_SerialConfigMassLoggingEn.Enabled = false;
|
|
#endregion
|
|
}
|
|
else
|
|
{
|
|
#region Definitions and initializations
|
|
nUD_SettingsStdDev.Enabled = true;
|
|
zGC_StdDevPath0.AutoScroll = true;
|
|
zGC_StdDevPath1.AutoScroll = true;
|
|
zGC_StdDevPath2.AutoScroll = true;
|
|
zGC_StdDevPath0.IsShowHScrollBar = true;
|
|
zGC_StdDevPath1.IsShowHScrollBar = true;
|
|
zGC_StdDevPath2.IsShowHScrollBar = true;
|
|
zGC_StdDevPath0.IsEnableZoom = true;
|
|
zGC_StdDevPath1.IsEnableZoom = true;
|
|
zGC_StdDevPath2.IsEnableZoom = true;
|
|
zGC_StdDevPath0.SetAutoScrollMargin(0, 0);
|
|
zGC_StdDevPath1.SetAutoScrollMargin(0, 0);
|
|
zGC_StdDevPath2.SetAutoScrollMargin(0, 0);
|
|
#endregion
|
|
#region Add values to zedgraph list
|
|
if (GraphCounterDataStdDevTotal[Constants.PATH2] > ClearValue)
|
|
{
|
|
#region Clear old display cache
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
for (UInt16 Hit = 0; Hit < 10; Hit++)
|
|
GraphListStdDevWindow[Path, Hit].Clear();
|
|
}
|
|
#endregion
|
|
#region Set new minval of data to be loaded into display cache
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
if ((XScaleMin[Path] - 100) >= 0)
|
|
NewScaleMin[Path] = XScaleMin[Path] - 100;
|
|
else
|
|
NewScaleMin[Path] = 0;
|
|
}
|
|
#endregion
|
|
#region Set new maxval of data to be loaded Int32o display cache
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
if ((NewScaleMin[Path] + (ClearValue + 200)) < TotalNumberOfValues - 1)
|
|
NewScaleMax[Path] = NewScaleMin[Path] + (ClearValue + 200);
|
|
else
|
|
NewScaleMax[Path] = TotalNumberOfValues - 1;
|
|
}
|
|
#endregion
|
|
#region Set new chart
|
|
Int32[,] LastIndex = new Int32[Constants.NumberOfPaths, 10];
|
|
for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
for (UInt16 Hit = 0; Hit < 10; Hit++)
|
|
{
|
|
for (DataIndex = 0; DataIndex < GraphListStdDevTotal[Path, Hit].Count; DataIndex++)
|
|
{
|
|
LastIndex[Path, Hit] = LastIndex[Path, Hit] + GraphListStdDevTotal[Path, Hit][(Int32)DataIndex].Count();
|
|
}
|
|
if (LastIndex[Path, Hit] > 0)
|
|
LastIndex[Path, Hit]--;
|
|
}
|
|
}
|
|
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
for (UInt16 Hit = 0; Hit < 10; Hit++)
|
|
{
|
|
for (Int32 i = NewScaleMin[Path]; i < NewScaleMax[Path]; i++)
|
|
{
|
|
try
|
|
{
|
|
#region Get index
|
|
DataIndex = (i) / (Constants.StdDevGraphListMaxElements);
|
|
PosIndex = (i) % (Constants.StdDevGraphListMaxElements);
|
|
#endregion
|
|
#region Copy list
|
|
if ((DataIndex <= GraphListStdDevTotal[Path, Hit].Count - 1) && (PosIndex <= GraphListStdDevTotal[Path, Hit][(Int32)DataIndex].Count - 1))
|
|
GraphListStdDevWindow[Path, Hit].Add(GraphListStdDevTotal[Path, Hit][(Int32)DataIndex].ElementAt((Int32)PosIndex));
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "cBStdDevEnable_CheckedChanged() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region Create graphs
|
|
CreateStdDevGraphPath0(zGC_StdDevPath0, ParamsStdDev[Constants.PATH0], false, tab_Maintab, cB_ReportStdDevPath0.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
CreateStdDevGraphPath1(zGC_StdDevPath1, ParamsStdDev[Constants.PATH1], false, tab_Maintab, cB_ReportStdDevPath1.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
CreateStdDevGraphPath2(zGC_StdDevPath2, ParamsStdDev[Constants.PATH2], false, tab_Maintab, cB_ReportStdDevPath2.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region Button for CSV-Converting
|
|
if ((!cB_MeanValuesEnable.Checked) && (!RawLoggingSingleMeterEnable) && (!LoggingCsvEn))
|
|
gB_DecodedData_CsvLogging.Enabled = true;
|
|
#endregion
|
|
#region Reset Std.-Deviation progress bar
|
|
pB_StdDeviation.Value = 0;
|
|
#endregion
|
|
#region Groupbox for X-Values
|
|
gB_SettingsStdDevGraph.Enabled = true;
|
|
#endregion
|
|
#region Stop maingraph with mean-values
|
|
if (lB_Graph_SelectGraph.Text.Contains("deviation") && (cB_GraphReset.Checked))
|
|
{
|
|
cB_GraphReset.Checked = false;
|
|
MessageBox.Show("Maingraph disabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
#endregion
|
|
#region tab_SerialConfig
|
|
if ((!cB_GraphReset.Checked) && (!cB_MeanValuesEnable.Checked))
|
|
cB_StdDevEnable.Enabled = true;
|
|
#endregion
|
|
}
|
|
#endregion
|
|
}
|
|
private void nUD_SettingsStdDev_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
pB_StdDeviation.Maximum = (Int32)nUD_SettingsStdDev.Value;
|
|
}
|
|
private void btn_StdDeviationCsvExport_Click(object sender, EventArgs e)
|
|
{
|
|
String Data = CsvStdDeviationPage(true);
|
|
String Fullpath = String.Empty;
|
|
Boolean FileDialogOK = false;
|
|
Boolean SavingOK = false;
|
|
|
|
WaitForBackgroundWorkers();
|
|
FileDialogOK = Files.SaveFiledialogCsv("Std Deviation", out Fullpath, DefaultCsvDirectory);
|
|
if (FileDialogOK)
|
|
{
|
|
DefaultCsvDirectory = Path.GetDirectoryName(Fullpath);
|
|
WaitForBackgroundWorkers();
|
|
SavingOK = Files.SaveText(Data, Fullpath, GetGlobalCulture());
|
|
}
|
|
|
|
if ((!SavingOK) && (FileDialogOK))
|
|
MessageBox.Show("Saving failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
#endregion
|
|
#region Redraw curves
|
|
private void cB_StdDev8CrossingsPath0_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if ((cB_StdDev8CrossingsPath0.Checked) && (cB_StdDevEnable.Checked) && (!cB_MeanValuesEnable.Checked))
|
|
{
|
|
cB_MeanValuesEnable.Checked = true;
|
|
MessageBox.Show("Mean calculationn enabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
|
|
CreateStdDevGraphPath0(zGC_StdDevPath0, ParamsStdDev[Constants.PATH0], false, tab_Maintab, cB_ReportStdDevPath0.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
}
|
|
|
|
private void cB_StdDev3CrossingsPath0_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if ((cB_StdDev3CrossingsPath0.Checked) && (cB_StdDevEnable.Checked) && (!cB_MeanValuesEnable.Checked))
|
|
{
|
|
cB_MeanValuesEnable.Checked = true;
|
|
MessageBox.Show("Mean calculation enabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
|
|
CreateStdDevGraphPath0(zGC_StdDevPath0, ParamsStdDev[Constants.PATH0], false, tab_Maintab, cB_ReportStdDevPath0.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
}
|
|
|
|
private void cB_StdDev8CrossingsPath1_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if ((cB_StdDev8CrossingsPath1.Checked) && (cB_StdDevEnable.Checked) && (!cB_MeanValuesEnable.Checked))
|
|
{
|
|
cB_MeanValuesEnable.Checked = true;
|
|
MessageBox.Show("Mean calculation enabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
|
|
CreateStdDevGraphPath1(zGC_StdDevPath1, ParamsStdDev[Constants.PATH1], false, tab_Maintab, cB_ReportStdDevPath1.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
}
|
|
|
|
private void cB_StdDev3CrossingsPath1_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if ((cB_StdDev3CrossingsPath1.Checked) && (cB_StdDevEnable.Checked) && (!cB_MeanValuesEnable.Checked))
|
|
{
|
|
cB_MeanValuesEnable.Checked = true;
|
|
MessageBox.Show("Mean calculation enabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
|
|
CreateStdDevGraphPath1(zGC_StdDevPath1, ParamsStdDev[Constants.PATH1], false, tab_Maintab, cB_ReportStdDevPath1.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
}
|
|
|
|
private void cB_StdDev8CrossingsPath2_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if ((cB_StdDev8CrossingsPath2.Checked) && (cB_StdDevEnable.Checked) && (!cB_MeanValuesEnable.Checked))
|
|
{
|
|
cB_MeanValuesEnable.Checked = true;
|
|
MessageBox.Show("Mean calculation enabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
|
|
CreateStdDevGraphPath2(zGC_StdDevPath2, ParamsStdDev[Constants.PATH2], false, tab_Maintab, cB_ReportStdDevPath2.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
}
|
|
|
|
private void cB_StdDev3CrossingsPath2_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if ((cB_StdDev3CrossingsPath2.Checked) && (cB_StdDevEnable.Checked) && (!cB_MeanValuesEnable.Checked))
|
|
{
|
|
cB_MeanValuesEnable.Checked = true;
|
|
MessageBox.Show("Mean calculation enabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
|
|
CreateStdDevGraphPath2(zGC_StdDevPath2, ParamsStdDev[Constants.PATH2], false, tab_Maintab, cB_ReportStdDevPath2.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
}
|
|
|
|
private void cB_StdDev0path0_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath0(zGC_StdDevPath0, ParamsStdDev[Constants.PATH0], false, tab_Maintab, cB_ReportStdDevPath0.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev1path0_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath0(zGC_StdDevPath0, ParamsStdDev[Constants.PATH0], false, tab_Maintab, cB_ReportStdDevPath0.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev2path0_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath0(zGC_StdDevPath0, ParamsStdDev[Constants.PATH0], false, tab_Maintab, cB_ReportStdDevPath0.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev3path0_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath0(zGC_StdDevPath0, ParamsStdDev[Constants.PATH0], false, tab_Maintab, cB_ReportStdDevPath0.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev4path0_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath0(zGC_StdDevPath0, ParamsStdDev[Constants.PATH0], false, tab_Maintab, cB_ReportStdDevPath0.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev5path0_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath0(zGC_StdDevPath0, ParamsStdDev[Constants.PATH0], false, tab_Maintab, cB_ReportStdDevPath0.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev6path0_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath0(zGC_StdDevPath0, ParamsStdDev[Constants.PATH0], false, tab_Maintab, cB_ReportStdDevPath0.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev7path0_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath0(zGC_StdDevPath0, ParamsStdDev[Constants.PATH0], false, tab_Maintab, cB_ReportStdDevPath0.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev0path1_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath1(zGC_StdDevPath1, ParamsStdDev[Constants.PATH1], false, tab_Maintab, cB_ReportStdDevPath1.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev1path1_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath1(zGC_StdDevPath1, ParamsStdDev[Constants.PATH1], false, tab_Maintab, cB_ReportStdDevPath1.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cBs_StdDev2path1_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath1(zGC_StdDevPath1, ParamsStdDev[Constants.PATH1], false, tab_Maintab, cB_ReportStdDevPath1.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev3path1_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath1(zGC_StdDevPath1, ParamsStdDev[Constants.PATH1], false, tab_Maintab, cB_ReportStdDevPath1.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev4path1_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath1(zGC_StdDevPath1, ParamsStdDev[Constants.PATH1], false, tab_Maintab, cB_ReportStdDevPath1.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev5path1_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath1(zGC_StdDevPath1, ParamsStdDev[Constants.PATH1], false, tab_Maintab, cB_ReportStdDevPath1.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev6path1_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath1(zGC_StdDevPath1, ParamsStdDev[Constants.PATH1], false, tab_Maintab, cB_ReportStdDevPath1.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev7path1_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath1(zGC_StdDevPath1, ParamsStdDev[Constants.PATH1], false, tab_Maintab, cB_ReportStdDevPath1.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev0path2_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath2(zGC_StdDevPath2, ParamsStdDev[Constants.PATH2], false, tab_Maintab, cB_ReportStdDevPath2.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev1path2_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath2(zGC_StdDevPath2, ParamsStdDev[Constants.PATH2], false, tab_Maintab, cB_ReportStdDevPath2.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev2path2_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath2(zGC_StdDevPath2, ParamsStdDev[Constants.PATH2], false, tab_Maintab, cB_ReportStdDevPath2.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev3path2_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath2(zGC_StdDevPath2, ParamsStdDev[Constants.PATH2], false, tab_Maintab, cB_ReportStdDevPath2.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev4path2_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath2(zGC_StdDevPath2, ParamsStdDev[Constants.PATH2], false, tab_Maintab, cB_ReportStdDevPath2.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev5path2_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath2(zGC_StdDevPath2, ParamsStdDev[Constants.PATH2], false, tab_Maintab, cB_ReportStdDevPath2.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev6path2_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath2(zGC_StdDevPath2, ParamsStdDev[Constants.PATH2], false, tab_Maintab, cB_ReportStdDevPath2.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
|
|
private void cB_StdDev7path2_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Redraw curves
|
|
CreateStdDevGraphPath2(zGC_StdDevPath2, ParamsStdDev[Constants.PATH2], false, tab_Maintab, cB_ReportStdDevPath2.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#region Standard deviation graphs
|
|
private void zGC_StdDevPath0_ScrollEvent(object sender, ScrollEventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Int32 TotalNumberOfValues = (Int32)GraphCounterDataStdDevTotal[Constants.PATH0];
|
|
Int32 XScaleMin = (Int32)Math.Round(zGC_StdDevPath0.GraphPane.XAxis.Scale.Min, 0);
|
|
Int32 XScaleMax = (Int32)Math.Round(zGC_StdDevPath0.GraphPane.XAxis.Scale.Max, 0);
|
|
Int32 NewScaleMin = 0;
|
|
Int32 NewScaleMax = 0;
|
|
Int32 ClearValue = (Int32)nUD_SettingsXrangeStdDevGraph.Value;
|
|
Int32 DataIndex = 0;
|
|
Int32 PosIndex = 0;
|
|
#endregion
|
|
#region Set new minval of data to be loaded Into display cache
|
|
if ((XScaleMin - 100) >= 0)
|
|
NewScaleMin = XScaleMin - 100;
|
|
else
|
|
NewScaleMin = 0;
|
|
#endregion
|
|
#region Set new maxval of data to be loaded into display cache
|
|
if ((NewScaleMin + (ClearValue + 200)) < TotalNumberOfValues - 1)
|
|
NewScaleMax = NewScaleMin + (ClearValue + 200);
|
|
else
|
|
NewScaleMax = TotalNumberOfValues - 1;
|
|
#endregion
|
|
#region Clear old display cache
|
|
for (UInt16 Hit = Constants.HIT0; Hit < 10; Hit++)
|
|
GraphListStdDevWindow[Constants.PATH0, Hit].Clear();
|
|
#endregion
|
|
#region Set new chart
|
|
Int32[] LastIndex = new Int32[10];
|
|
for (UInt16 Hit = 0; Hit < 10; Hit++)
|
|
{
|
|
for (DataIndex = 0; DataIndex < GraphListStdDevTotal[Constants.PATH0, Hit].Count(); DataIndex++)
|
|
{
|
|
LastIndex[Hit] = LastIndex[Hit] + GraphListStdDevTotal[Constants.PATH0, Hit][(Int32)DataIndex].Count();
|
|
}
|
|
if (LastIndex[Hit] > 0)
|
|
LastIndex[Hit]--;
|
|
}
|
|
for (UInt16 Hit = 0; Hit < 10; Hit++)
|
|
{
|
|
Int32 StartIndex = 0;
|
|
if (LastIndex[Hit] - 200 > 0)
|
|
{
|
|
StartIndex = LastIndex[Hit] - 200;
|
|
}
|
|
else
|
|
StartIndex = 0;
|
|
for (Int32 i = NewScaleMin; i < NewScaleMax; i++)
|
|
{
|
|
try
|
|
{
|
|
#region Get index
|
|
DataIndex = (i) / (Constants.StdDevGraphListMaxElements);
|
|
PosIndex = (i) % (Constants.StdDevGraphListMaxElements);
|
|
#endregion
|
|
#region Copy list
|
|
if ((DataIndex <= GraphListStdDevTotal[Constants.PATH0, Hit].Count - 1) && (PosIndex <= GraphListStdDevTotal[Constants.PATH0, Hit][(Int32)DataIndex].Count() - 1))
|
|
GraphListStdDevWindow[Constants.PATH0, Hit].Add(GraphListStdDevTotal[Constants.PATH0, Hit][(Int32)DataIndex].ElementAt((Int32)PosIndex));
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "zGC_StdDevPath0_ScrollEvent() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
CreateStdDevGraphPath0(zGC_StdDevPath0, ParamsStdDev[Constants.PATH0], false, tab_Maintab, cB_ReportStdDevPath0.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
private void zGC_StdDevPath1_ScrollEvent(object sender, ScrollEventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Int32 TotalNumberOfValues = (Int32)GraphCounterDataStdDevTotal[Constants.PATH1];
|
|
Int32 XScaleMin = (Int32)Math.Round(zGC_StdDevPath1.GraphPane.XAxis.Scale.Min, 0);
|
|
Int32 XScaleMax = (Int32)Math.Round(zGC_StdDevPath1.GraphPane.XAxis.Scale.Max, 0);
|
|
Int32 NewScaleMin = 0;
|
|
Int32 NewScaleMax = 0;
|
|
Int32 ClearValue = (Int32)nUD_SettingsXrangeStdDevGraph.Value;
|
|
Int32 DataIndex = 0;
|
|
Int32 PosIndex = 0;
|
|
#endregion
|
|
#region Set new minval of data to be loaded Int32o display cache
|
|
if ((XScaleMin - 100) >= 0)
|
|
NewScaleMin = XScaleMin - 100;
|
|
else
|
|
NewScaleMin = 0;
|
|
#endregion
|
|
#region Set new maxval of data to be loaded Int32o display cache
|
|
if ((NewScaleMin + (ClearValue + 200)) < TotalNumberOfValues - 1)
|
|
NewScaleMax = NewScaleMin + (ClearValue + 200);
|
|
else
|
|
NewScaleMax = TotalNumberOfValues - 1;
|
|
#endregion
|
|
#region Clear old display cache
|
|
for (UInt16 Hit = 0; Hit < 10; Hit++)
|
|
GraphListStdDevWindow[Constants.PATH1, Hit].Clear();
|
|
#endregion
|
|
#region Set new chart
|
|
Int32[] LastIndex = new Int32[10];
|
|
for (UInt16 Hit = 0; Hit < 10; Hit++)
|
|
{
|
|
for (DataIndex = 0; DataIndex < GraphListStdDevTotal[Constants.PATH1, Hit].Count; DataIndex++)
|
|
{
|
|
LastIndex[Hit] = LastIndex[Hit] + GraphListStdDevTotal[Constants.PATH1, Hit][(Int32)DataIndex].Count();
|
|
}
|
|
if (LastIndex[Hit] > 0)
|
|
LastIndex[Hit]--;
|
|
}
|
|
for (UInt16 Hit = 0; Hit < 10; Hit++)
|
|
{
|
|
Int32 StartIndex = 0;
|
|
if (LastIndex[Hit] - 200 > 0)
|
|
{
|
|
StartIndex = LastIndex[Hit] - 200;
|
|
}
|
|
else
|
|
StartIndex = 0;
|
|
for (Int32 i = NewScaleMin; i < NewScaleMax; i++)
|
|
{
|
|
try
|
|
{
|
|
#region Get index
|
|
DataIndex = (i) / (Constants.StdDevGraphListMaxElements);
|
|
PosIndex = (i) % (Constants.StdDevGraphListMaxElements);
|
|
#endregion
|
|
#region Copy list
|
|
if ((DataIndex <= GraphListStdDevTotal[Constants.PATH1, Hit].Count - 1) && (PosIndex <= GraphListStdDevTotal[Constants.PATH1, Hit][(Int32)DataIndex].Count() - 1))
|
|
GraphListStdDevWindow[Constants.PATH1, Hit].Add(GraphListStdDevTotal[Constants.PATH1, Hit][(Int32)DataIndex].ElementAt((Int32)PosIndex));
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "zGC_StdDevPath1_ScrollEvent() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
CreateStdDevGraphPath1(zGC_StdDevPath1, ParamsStdDev[Constants.PATH1], false, tab_Maintab, cB_ReportStdDevPath1.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
private void zGC_StdDevPath2_ScrollEvent(object sender, ScrollEventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Int32 TotalNumberOfValues = (Int32)GraphCounterDataStdDevTotal[Constants.PATH2];
|
|
Int32 XScaleMin = (Int32)Math.Round(zGC_StdDevPath2.GraphPane.XAxis.Scale.Min, 0);
|
|
Int32 XScaleMax = (Int32)Math.Round(zGC_StdDevPath2.GraphPane.XAxis.Scale.Max, 0);
|
|
Int32 NewScaleMin = 0;
|
|
Int32 NewScaleMax = 0;
|
|
Int32 ClearValue = (Int32)nUD_SettingsXrangeStdDevGraph.Value;
|
|
Int32 DataIndex = 0;
|
|
Int32 PosIndex = 0;
|
|
#endregion
|
|
#region Set new minval of data to be loaded into display cache
|
|
if ((XScaleMin - 100) >= 0)
|
|
NewScaleMin = XScaleMin - 100;
|
|
else
|
|
NewScaleMin = 0;
|
|
#endregion
|
|
#region Set new maxval of data to be loaded Int32o display cache
|
|
if ((NewScaleMin + (ClearValue + 200)) < TotalNumberOfValues - 1)
|
|
NewScaleMax = NewScaleMin + (ClearValue + 200);
|
|
else
|
|
NewScaleMax = TotalNumberOfValues - 1;
|
|
#endregion
|
|
#region Clear old display cache
|
|
for (UInt16 Hit = 0; Hit < 10; Hit++)
|
|
GraphListStdDevWindow[Constants.PATH2, Hit].Clear();
|
|
#endregion
|
|
#region Set new chart
|
|
Int32[] LastIndex = new Int32[10];
|
|
for (UInt16 Hit = 0; Hit < 10; Hit++)
|
|
{
|
|
for (DataIndex = 0; DataIndex < GraphListStdDevTotal[Constants.PATH2, Hit].Count; DataIndex++)
|
|
{
|
|
LastIndex[Hit] = LastIndex[Hit] + GraphListStdDevTotal[Constants.PATH2, Hit][(Int32)DataIndex].Count();
|
|
}
|
|
if (LastIndex[Hit] > 0)
|
|
LastIndex[Hit]--;
|
|
}
|
|
for (UInt16 Hit = 0; Hit < 10; Hit++)
|
|
{
|
|
Int32 StartIndex = 0;
|
|
if (LastIndex[Hit] - 200 > 0)
|
|
{
|
|
StartIndex = LastIndex[Hit] - 200;
|
|
}
|
|
else
|
|
StartIndex = 0;
|
|
for (Int32 i = NewScaleMin; i < NewScaleMax; i++)
|
|
{
|
|
try
|
|
{
|
|
#region Get index
|
|
DataIndex = (i) / (Constants.StdDevGraphListMaxElements);
|
|
PosIndex = (i) % (Constants.StdDevGraphListMaxElements);
|
|
#endregion
|
|
#region Copy list
|
|
if ((DataIndex <= GraphListStdDevTotal[Constants.PATH2, Hit].Count - 1) && (PosIndex <= GraphListStdDevTotal[Constants.PATH2, Hit][(Int32)DataIndex].Count() - 1))
|
|
GraphListStdDevWindow[Constants.PATH2, Hit].Add(GraphListStdDevTotal[Constants.PATH2, Hit][(Int32)DataIndex].ElementAt((Int32)PosIndex));
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "zGC_StdDevPath2_ScrollEvent() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
CreateStdDevGraphPath2(zGC_StdDevPath2, ParamsStdDev[Constants.PATH2], false, tab_Maintab, cB_ReportStdDevPath2.Checked, (UInt32)nUD_SettingsXrangeStdDevGraph.Value);
|
|
#endregion
|
|
}
|
|
private void zGC_StdDevPath0_ContextMenuBuilder(ZedGraphControl sender, ContextMenuStrip menuStrip, Point mousePt, ZedGraphControl.ContextMenuObjectState objState)
|
|
{
|
|
// Remove item "Set scale to default"
|
|
Misc.MyContextMenuBuilder(zGC_StdDevPath0, menuStrip, mousePt, objState);
|
|
}
|
|
private void zGC_StdDevPath1_ContextMenuBuilder(ZedGraphControl sender, ContextMenuStrip menuStrip, Point mousePt, ZedGraphControl.ContextMenuObjectState objState)
|
|
{
|
|
// Remove item "Set scale to default"
|
|
Misc.MyContextMenuBuilder(zGC_StdDevPath1, menuStrip, mousePt, objState);
|
|
}
|
|
private void zGC_StdDevPath2_ContextMenuBuilder(ZedGraphControl sender, ContextMenuStrip menuStrip, Point mousePt, ZedGraphControl.ContextMenuObjectState objState)
|
|
{
|
|
// Remove item "Set scale to default"
|
|
Misc.MyContextMenuBuilder(zGC_StdDevPath2, menuStrip, mousePt, objState);
|
|
}
|
|
#endregion
|
|
#region Mean values control elements
|
|
private void nUD_SettingsMean_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
#region Reset progress bars
|
|
pB_Mean.Maximum = (Int32)nUD_SettingsMean.Value;
|
|
// pB_MainGraphPrepareData.Maximum = (Int32)nUD_SettingsMean.Value;
|
|
pB_MeanValuesTemperaturePath0.Maximum = (Int32)nUD_SettingsMean.Value;
|
|
pB_MeanValuesTemperaturePath1.Maximum = (Int32)nUD_SettingsMean.Value;
|
|
pB_MeanValuesTemperaturePath2.Maximum = (Int32)nUD_SettingsMean.Value;
|
|
#endregion
|
|
#region Set graph title
|
|
if (lB_Graph_SelectGraph.Text == "Standard deviation (Mean over 8 zero crossings)")
|
|
ParamsMainGraph.Title = $"Standard Deviation of mean of 8 zero crossings,\nMean over {nUD_SettingsMean.Value.ToString(GetGlobalCulture())} values";
|
|
if (lB_Graph_SelectGraph.Text == "Standard deviation (Mean over 3 zero crossings)")
|
|
ParamsMainGraph.Title = $"Standard deviation of mean of 3 zero crossings,\nMean over {nUD_SettingsMean.Value.ToString(GetGlobalCulture())} values";
|
|
|
|
//Maingraph1.CreateGraphs(false, GetTabStatus(), GetSelectedPath());
|
|
#endregion
|
|
}
|
|
private void cB_MeanValuesEnable_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if (cB_MeanValuesEnable.Checked)
|
|
{
|
|
#region Reset debug counters
|
|
Display.DebugElapsedValuesCounterReset();
|
|
#endregion
|
|
#region Mean labels and control elements
|
|
nUD_SettingsMean.Enabled = false;
|
|
ResetAllMeanLabels();
|
|
cB_MultihitOverallAvgEn.Enabled = false;
|
|
#endregion
|
|
#region Button for CSV-Converting
|
|
gB_DecodedData_CsvLogging.Enabled = false;
|
|
#endregion
|
|
#region Progress bars
|
|
pB_Mean.Maximum = (Int32)nUD_SettingsMean.Value;
|
|
pB_MeanValuesTemperaturePath0.Maximum = (Int32)nUD_SettingsMean.Value;
|
|
pB_MeanValuesTemperaturePath1.Maximum = (Int32)nUD_SettingsMean.Value;
|
|
pB_MeanValuesTemperaturePath2.Maximum = (Int32)nUD_SettingsMean.Value;
|
|
#endregion
|
|
#region tab_SerialConfig
|
|
cB_SerialConfigMassLoggingEn.Enabled = false;
|
|
#endregion
|
|
}
|
|
else
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean DisableMaingraph = false;
|
|
Boolean DisableStdDeviationGraph = false;
|
|
#endregion
|
|
#region Set control elements
|
|
nUD_SettingsMean.Enabled = true;
|
|
cB_MultihitOverallAvgEn.Enabled = true;
|
|
#endregion
|
|
#region Reset progress bars
|
|
pB_Mean.Value = 0;
|
|
pB_MeanValuesTemperaturePath0.Value = 0;
|
|
pB_MeanValuesTemperaturePath1.Value = 0;
|
|
pB_MeanValuesTemperaturePath2.Value = 0;
|
|
pB_MainGraphPrepareData.Value = 0;
|
|
#endregion
|
|
#region Reset counters
|
|
MeanCalculate.ResetCounters(ref TelegramCounterTofMean, ref TelegramCounterDifTofMean, ref TelegramCounterMultiHitMean, ref TelegramCounterOthersMean, ref TelegramCounterTemperatureMean, ref TelegramCounterFlowMean);
|
|
#endregion
|
|
#region Reset data lists
|
|
MeanCalculate.ResetProcessingListsTof(ref ProcessingTofUpMean, ref ProcessingTofDownMean, ref ProcessingDifTofMean);
|
|
MeanCalculate.ResetProcessingListsMultihitMean(ref Processing3HitsMean, ref Processing8HitsMean, ref Processing3HitsTotalMean, ref Processing8HitsTotalMean);
|
|
MeanCalculate.ResetProcessingListsOthersMean(ref ProcessingPulsewidthUpMean, ref ProcessingPulsewidthDownMean, ref ProcessingAmplitudeUpMean, ref ProcessingAmplitudeDownMean, ref ProcessingTemperatureMean, ref ProcessingFlowMean);
|
|
#endregion
|
|
#region Reset calculation results
|
|
MeanCalculate.ResetCalculationResults(ref Decoded);
|
|
#endregion
|
|
#region Button for CSV-Converting
|
|
if ((!cB_StdDevEnable.Checked) && (!RawLoggingSingleMeterEnable) && (!LoggingCsvEn))
|
|
gB_DecodedData_CsvLogging.Enabled = true;
|
|
#endregion
|
|
#region Stop maingraph with mean-values
|
|
if (lB_Graph_SelectGraph.Text.Contains("Mean") && (cB_GraphReset.Checked))
|
|
{
|
|
cB_GraphReset.Checked = false;
|
|
DisableMaingraph = true;
|
|
}
|
|
#endregion
|
|
#region Stop standard deviation graphs
|
|
if ((cB_StdDevEnable.Checked) &&
|
|
(cB_StdDev8CrossingsPath0.Checked || cB_StdDev3CrossingsPath0.Checked ||
|
|
cB_StdDev8CrossingsPath1.Checked || cB_StdDev3CrossingsPath1.Checked ||
|
|
cB_StdDev8CrossingsPath2.Checked || cB_StdDev3CrossingsPath2.Checked))
|
|
{
|
|
cB_StdDevEnable.Checked = false;
|
|
DisableStdDeviationGraph = true;
|
|
}
|
|
if ((DisableMaingraph) && (!DisableStdDeviationGraph))
|
|
{
|
|
MessageBox.Show("Maingraph disabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
return;
|
|
}
|
|
if ((!DisableMaingraph) && (DisableStdDeviationGraph))
|
|
{
|
|
MessageBox.Show("Std deviation graph disabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
return;
|
|
}
|
|
if ((DisableMaingraph) && (DisableStdDeviationGraph))
|
|
{
|
|
MessageBox.Show("Maingraph and Std deviation graph disabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
return;
|
|
}
|
|
#endregion
|
|
#region tab_SerialConfig
|
|
if ((!cB_StdDevEnable.Checked) && (!cB_GraphReset.Checked))
|
|
cB_SerialConfigMassLoggingEn.Enabled = true;
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_MeanValuesCsvExport_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
String Data = CsvMeanPage(true);
|
|
String Fullpath = String.Empty;
|
|
Boolean FileDialogOk = false;
|
|
Boolean SavingOk = false;
|
|
#endregion
|
|
|
|
WaitForBackgroundWorkers();
|
|
FileDialogOk = Files.SaveFiledialogCsv("Mean Values", out Fullpath, DefaultCsvDirectory);
|
|
if (FileDialogOk)
|
|
{
|
|
DefaultCsvDirectory = Path.GetDirectoryName(Fullpath);
|
|
WaitForBackgroundWorkers();
|
|
SavingOk = Files.SaveText(Data, Fullpath, GetGlobalCulture());
|
|
}
|
|
|
|
if ((!SavingOk) && (FileDialogOk))
|
|
MessageBox.Show("Saving failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
|
|
private void cB_MultihitOverallAvgEn_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
Boolean[] PathSelected = new Boolean[Constants.NumberOfPaths] { cB_GraphOptionEnPath0.Checked, cB_GraphOptionEnPath1.Checked, cB_GraphOptionEnPath2.Checked };
|
|
InitStdDevGraph((Double)nUD_SettingsXrangeStdDevGraph.Value, cB_ReportStdDevPath0.Checked, cB_ReportStdDevPath1.Checked, cB_ReportStdDevPath2.Checked, (Int32)nUD_SettingsStdDev.Value, (Int32)nUD_SettingsMean.Value, cB_MultihitOverallAvgEn.Checked);
|
|
//if (!cB_GraphReset.Checked)
|
|
// Maingraph1.SetTitle((Int32)nUD_SettingsMean.Value);
|
|
}
|
|
#endregion
|
|
#region Maingraph control elements
|
|
private void lB_Graph_SelectGraph_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
//Maingraph1.Reset((Double)nUD_SettingsXMainGraph.Value);
|
|
//Maingraph1.InitParameters((Double)nUD_SettingsXMainGraph.Value, lB_Graph_SelectGraph.Text, cB_MultihitOverallAvgEn.Checked, (Int32)nUD_SettingsStdDev.Value, (Int32)nUD_SettingsMean.Value);
|
|
//Maingraph1.InitGraph();
|
|
if (lB_Graph_SelectGraph.Text.Contains("Flow (relative"))
|
|
gB_MaingraphNomVal.Visible = true;
|
|
else
|
|
gB_MaingraphNomVal.Visible = false;
|
|
|
|
#region Mean without standard deviation
|
|
if (lB_Graph_SelectGraph.Text.Contains("Mean") && (!lB_Graph_SelectGraph.Text.Contains("deviation")) && cB_GraphReset.Checked)
|
|
{
|
|
if (!cB_MeanValuesEnable.Checked)
|
|
{
|
|
cB_MeanValuesEnable.Checked = true;
|
|
MessageBox.Show("Mean calculation enabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
return;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Standard deviation
|
|
if (lB_Graph_SelectGraph.Text.Contains("deviation") && cB_GraphReset.Checked)
|
|
{
|
|
if ((!cB_MeanValuesEnable.Checked) && (cB_StdDevEnable.Checked))
|
|
{
|
|
WaitForBackgroundWorkers();
|
|
cB_MeanValuesEnable.Checked = true;
|
|
MessageBox.Show("Mean calculation enabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
return;
|
|
}
|
|
|
|
if ((cB_MeanValuesEnable.Checked) && (!cB_StdDevEnable.Checked))
|
|
{
|
|
WaitForBackgroundWorkers();
|
|
cB_StdDevEnable.Checked = true;
|
|
MessageBox.Show("Std deviation calculation enabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
return;
|
|
}
|
|
|
|
if ((!cB_MeanValuesEnable.Checked) && (!cB_StdDevEnable.Checked))
|
|
{
|
|
WaitForBackgroundWorkers();
|
|
cB_MeanValuesEnable.Checked = true;
|
|
cB_StdDevEnable.Checked = true;
|
|
MessageBox.Show("Mean and Std deviation calculation enabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
return;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
private void btn_Graph_SaveDiagram_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
String FullFilename = String.Empty;
|
|
String Fullpath = String.Empty;
|
|
String Itemname = lB_Graph_SelectGraph.Text;//.Replace(" ", "");
|
|
Boolean FileDialogOK = false;
|
|
Boolean SavingOK = false;
|
|
#endregion
|
|
#region Everything else
|
|
WaitForBackgroundWorkers();
|
|
FileDialogOK = Files.SaveFiledialogPng(Itemname, out Fullpath, DefaultImagesDirectory);
|
|
if (FileDialogOK)
|
|
{
|
|
DefaultImagesDirectory = Path.GetDirectoryName(Fullpath);
|
|
SavingOK = Files.SaveImage(zGC_MainGraph, Fullpath, GetGlobalCulture());
|
|
}
|
|
#endregion
|
|
}
|
|
private void cB_GraphReset_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
CultureInfo culture = GetGlobalCulture();
|
|
Int32 xRange = (Int32)nUD_SettingsXMainGraph.Value;
|
|
Int32 TotalNumberOfValues = (Int32)GraphCounterDataMainTotal[Constants.PATH2];
|
|
Int32 NewScaleMin = 0;
|
|
Int32 NewScaleMax = 0;
|
|
Int32 DataIndex = 0;
|
|
Int32 XScaleMin = (Int32)Math.Round(zGC_MainGraph.GraphPane.XAxis.Scale.Min, 0);
|
|
Int32 XScaleMax = (Int32)Math.Round(zGC_MainGraph.GraphPane.XAxis.Scale.Max, 0);
|
|
String SelectedOption = lB_Graph_SelectGraph.Text;
|
|
#endregion
|
|
if (cB_GraphReset.Checked)
|
|
{
|
|
FormControl.GraphButtonsDisable(true);
|
|
if (String.IsNullOrEmpty(lB_Graph_SelectGraph.Text))
|
|
{
|
|
gB_SettingsMaingraph.Enabled = false;
|
|
gB_GraphOptionsPathsEn.Enabled = false;
|
|
MessageBox.Show("Select item first", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
cB_GraphReset.Checked = false;
|
|
gB_SettingsMaingraph.Enabled = true;
|
|
gB_GraphOptionsPathsEn.Enabled = true;
|
|
FormControl.GraphButtonsDisable(false);
|
|
return;
|
|
}
|
|
#region Reset settings
|
|
//Maingraph1.Reset((Double)nUD_SettingsXMainGraph.Value);
|
|
ResetMainGraph();
|
|
InitMainGraph(SelectedOption, (Double)nUD_SettingsXMainGraph.Value, (Int32)nUD_SettingsStdDev.Value, (Int32)nUD_SettingsMean.Value, cB_MultihitOverallAvgEn.Checked);
|
|
Boolean[] PathSelected = new Boolean[Constants.NumberOfPaths] { cB_GraphOptionEnPath0.Checked, cB_GraphOptionEnPath1.Checked, cB_GraphOptionEnPath2.Checked };
|
|
//Maingraph1.InitParameters((Double)nUD_SettingsXMainGraph.Value, lB_Graph_SelectGraph.Text, cB_MultihitOverallAvgEn.Checked, (Int32)nUD_SettingsStdDev.Value, (Int32)nUD_SettingsMean.Value);
|
|
//Maingraph1.InitGraph();
|
|
|
|
|
|
lB_Graph_SelectGraph.Enabled = false;
|
|
gB_SettingsMaingraph.Enabled = false;
|
|
zGC_MainGraph.IsShowHScrollBar = false;
|
|
zGC_MainGraph.IsEnableZoom = false;
|
|
|
|
btn_Graph_OpenRaw.Enabled = false;
|
|
#endregion
|
|
#region Enable mean/ std deviation calculation
|
|
if (SelectedOption.Contains("Mean"))
|
|
{
|
|
#region Enable maingraph progress bar
|
|
l_MainGraphPrepareData.Visible = true;
|
|
pB_MainGraphPrepareData.Visible = true;
|
|
#endregion
|
|
if ((SelectedOption.Contains("deviation")))
|
|
{
|
|
#region Std deviation
|
|
// Enable mean and std deviation
|
|
if ((Boolean.Equals(cB_MeanValuesEnable.Checked, false)) && (cB_StdDevEnable.Checked == false))
|
|
{
|
|
cB_MeanValuesEnable.Checked = true;
|
|
cB_StdDevEnable.Checked = true;
|
|
MessageBox.Show("Mean and Std deviation calculation enabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
return;
|
|
}
|
|
|
|
// Enable mean
|
|
if ((Boolean.Equals(cB_MeanValuesEnable.Checked, false)) && (cB_StdDevEnable.Checked == true))
|
|
{
|
|
cB_MeanValuesEnable.Checked = true;
|
|
MessageBox.Show("Mean calculation enabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
return;
|
|
}
|
|
|
|
// Enable std deviation
|
|
if ((Boolean.Equals(cB_MeanValuesEnable.Checked, true)) && (cB_StdDevEnable.Checked == false))
|
|
{
|
|
cB_StdDevEnable.Checked = true;
|
|
MessageBox.Show("Std deviation calculation enabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
return;
|
|
}
|
|
#endregion
|
|
}
|
|
#region No std deviation
|
|
else
|
|
{
|
|
if (!cB_MeanValuesEnable.Checked)
|
|
{
|
|
cB_MeanValuesEnable.Checked = true;
|
|
MessageBox.Show("Mean calculation enabled", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region Graph
|
|
gB_MaingraphNomVal.Enabled = false;
|
|
#endregion
|
|
#region tab_SerialConfig
|
|
cB_SerialConfigMassLoggingEn.Enabled = false;
|
|
#endregion
|
|
}
|
|
else
|
|
{
|
|
FormControl.GraphButtonsDisable(false);
|
|
#region Disable maingraph progress bar
|
|
l_MainGraphPrepareData.Visible = false;
|
|
pB_MainGraphPrepareData.Visible = false;
|
|
gB_MaingraphNomVal.Enabled = true;
|
|
#endregion
|
|
|
|
gB_SettingsMaingraph.Enabled = true;
|
|
#region Definitions and initializations
|
|
zGC_MainGraph.AutoScroll = true;
|
|
zGC_MainGraph.IsShowHScrollBar = true;
|
|
zGC_MainGraph.IsShowVScrollBar = false;
|
|
zGC_MainGraph.IsEnableZoom = true;
|
|
zGC_MainGraph.SetAutoScrollMargin(0, 0);
|
|
lB_Graph_SelectGraph.Enabled = true;
|
|
#endregion
|
|
#region Clear old display cache
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
GraphListMainWindow[Path].Clear();
|
|
#endregion
|
|
#region Set new minval of data to be loaded into display cache
|
|
if ((XScaleMin - 100) >= 0)
|
|
NewScaleMin = XScaleMin - 100;
|
|
else
|
|
NewScaleMin = 0;
|
|
#endregion
|
|
#region Set new maxval of data to be loaded into display cache
|
|
if ((NewScaleMin + (xRange + 200)) < TotalNumberOfValues - 1)
|
|
NewScaleMax = NewScaleMin + (xRange + 200);
|
|
else
|
|
NewScaleMax = TotalNumberOfValues - 1;
|
|
#endregion
|
|
#region Set new chart
|
|
Int32[] LastIndex = new Int32[Constants.NumberOfPaths] { 0, 0, 0 };
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
for (DataIndex = 0; DataIndex < GraphListMainTotal[Path].Count(); DataIndex++)
|
|
{
|
|
LastIndex[Path] = LastIndex[Path] + GraphListMainTotal[Path][(Int32)DataIndex].Count();
|
|
}
|
|
if (LastIndex[Path] > 0)
|
|
LastIndex[Path]--;
|
|
}
|
|
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
for (Int32 index = NewScaleMin; index < NewScaleMax; index++)
|
|
{
|
|
try
|
|
{
|
|
Graphs.GetFromBackup(Path, index, GraphListMainTotal, ref GraphListMainWindow);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "cB_GraphReset_CheckedChanged() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
}
|
|
}
|
|
}
|
|
// Boolean[] PathsSelected = new Boolean[Constants.NumberOfPaths] { cB_GraphOptionEnPath0.Checked, cB_GraphOptionEnPath1.Checked, cB_GraphOptionEnPath2.Checked };
|
|
CreateMainGraphs(zGC_MainGraph, ParamsMainGraph, false);
|
|
//Maingraph1.CreateGraphs(false, GetTabStatus(), GetSelectedPath());
|
|
#endregion
|
|
#region Open raw file
|
|
btn_Graph_OpenRaw.Enabled = true;
|
|
#endregion
|
|
#region tab_SerialConfig
|
|
if ((!cB_StdDevEnable.Checked) && (!cB_MeanValuesEnable.Checked))
|
|
cB_SerialConfigMassLoggingEn.Enabled = true;
|
|
#endregion
|
|
}
|
|
|
|
}
|
|
private void cB_GraphOptionEnPath0_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
CreateMainGraphs(zGC_MainGraph, ParamsMainGraph, false);
|
|
}
|
|
private void cB_GraphOptionEnPath1_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
CreateMainGraphs(zGC_MainGraph, ParamsMainGraph, false);
|
|
}
|
|
private void cB_GraphOptionEnPath2_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
CreateMainGraphs(zGC_MainGraph, ParamsMainGraph, false);
|
|
}
|
|
private void zGC_MainGraph_ScrollEvent(object sender, ScrollEventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Int32 TotalNumberOfValues = (Int32)GraphCounterDataMainTotal[Constants.PATH2];
|
|
Int32 XScaleMin = (Int32)Math.Round(zGC_MainGraph.GraphPane.XAxis.Scale.Min, 0);
|
|
Int32 XScaleMax = (Int32)Math.Round(zGC_MainGraph.GraphPane.XAxis.Scale.Max, 0);
|
|
Int32 NewScaleMin = 0;
|
|
Int32 NewScaleMax = 0;
|
|
Int32 ClearValue = (Int32)nUD_SettingsXMainGraph.Value;
|
|
#endregion
|
|
#region Set new minval of data to be loaded into display cache
|
|
if ((XScaleMin - 100) >= 0)
|
|
NewScaleMin = XScaleMin - 100;
|
|
else
|
|
NewScaleMin = 0;
|
|
#endregion
|
|
#region Set new maxval of data to be loaded into display cache
|
|
if ((NewScaleMin + (ClearValue + 200)) < TotalNumberOfValues - 1)
|
|
NewScaleMax = NewScaleMin + (ClearValue + 200);
|
|
else
|
|
NewScaleMax = TotalNumberOfValues - 1;
|
|
#endregion
|
|
#region Clear old display cache
|
|
for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++)
|
|
GraphListMainWindow[Path].Clear();
|
|
#endregion
|
|
#region Set new chart
|
|
Int32[] LastIndex = new Int32[Constants.NumberOfPaths] { 0, 0, 0 };
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
for (Int32 DataIndex = 0; DataIndex < GraphListMainTotal[Path].Count(); DataIndex++)
|
|
{
|
|
LastIndex[Path] = LastIndex[Path] + GraphListMainTotal[Path][(Int32)DataIndex].Count();
|
|
}
|
|
if (LastIndex[Path] > 0)
|
|
LastIndex[Path]--;
|
|
}
|
|
|
|
for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++)
|
|
{
|
|
Int32 StartIndex = 0;
|
|
if (LastIndex[Path] - 200 > 0)
|
|
{
|
|
StartIndex = LastIndex[Path] - 200;
|
|
}
|
|
else
|
|
StartIndex = 0;
|
|
for (Int32 Index = NewScaleMin; Index < NewScaleMax; Index++)
|
|
{
|
|
try
|
|
{
|
|
Graphs.GetFromBackup(Path, Index, GraphListMainTotal, ref GraphListMainWindow);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "GC_MainGraph_ScrollEvent() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
CreateMainGraphs(zGC_MainGraph, ParamsMainGraph, false);
|
|
#endregion
|
|
}
|
|
private void zGC_MainGraph_ContextMenuBuilder(ZedGraphControl sender, ContextMenuStrip menuStrip, Point mousePt, ZedGraphControl.ContextMenuObjectState objState)
|
|
{
|
|
// Remove item "Set scale to default"
|
|
Misc.MyContextMenuBuilder(zGC_MainGraph, menuStrip, mousePt, objState);
|
|
}
|
|
private void nUD_MaingraphNomVal_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
if (nUD_MaingraphNomVal.Value == 0)
|
|
{
|
|
if (MaingraphPreviousValue > 0)
|
|
nUD_MaingraphNomVal.Value = (decimal)-0.1;
|
|
else
|
|
nUD_MaingraphNomVal.Value = (decimal)0.1;
|
|
|
|
MaingraphPreviousValue = (Double)nUD_MaingraphNomVal.Value;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region JSON control elements
|
|
private void btn_JsonUpdate_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
|
|
|
|
//Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly()), "configuration.json");
|
|
|
|
var path = Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "configuration.json");
|
|
MessageBox.Show($"JSON file is located '{path}'.{Environment.NewLine}If you want to upgrade, please do this on this file and reconnect to meter", "Json file location", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
|
|
public class Privilege
|
|
{
|
|
public string lvl1 { get; set; }
|
|
public string lvl2 { get; set; }
|
|
public string lvl3 { get; set; }
|
|
public string lvl4 { get; set; }
|
|
public string lvl5 { get; set; }
|
|
public string lvl6 { get; set; }
|
|
public string lvl7 { get; set; }
|
|
public string lvl8 { get; set; }
|
|
}
|
|
|
|
public class RegDefExtended
|
|
{
|
|
public string type { get; set; }
|
|
public int id { get; set; }
|
|
public Privilege privilege { get; set; }
|
|
}
|
|
|
|
private void lB_JsonItems_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
|
|
try
|
|
{
|
|
|
|
UInt16 MeterNumber = 1;
|
|
if (cB_SerialConfigMassMassLoggingEn.Checked)
|
|
{
|
|
if (rB_JsonMeter1.Checked)
|
|
MeterNumber = 1;
|
|
if (rB_JsonMeter2.Checked)
|
|
MeterNumber = 2;
|
|
if (rB_JsonMeter3.Checked)
|
|
MeterNumber = 3;
|
|
}
|
|
else
|
|
MeterNumber = 1;
|
|
|
|
|
|
var regDef = CheckMeterConnected(MeterNumber)
|
|
.GetRegisterDefinitionByName(lB_JsonItems.SelectedItem.ToString());
|
|
|
|
|
|
String Datatype = regDef.DataType.Name;
|
|
Display.LabelJsonDatatype(Datatype);
|
|
dGV_JsonMeter1.Rows[0].Cells[0].Value = regDef.Detail.Privilege.Lvl1.ToString();
|
|
dGV_JsonMeter1.Rows[0].Cells[1].Value = regDef.Detail.Privilege.Lvl2.ToString();
|
|
dGV_JsonMeter1.Rows[0].Cells[2].Value = regDef.Detail.Privilege.Lvl3.ToString();
|
|
dGV_JsonMeter1.Rows[0].Cells[3].Value = regDef.Detail.Privilege.Lvl4.ToString();
|
|
dGV_JsonMeter1.Rows[0].Cells[4].Value = regDef.Detail.Privilege.Lvl5.ToString();
|
|
dGV_JsonMeter1.Rows[0].Cells[5].Value = regDef.Detail.Privilege.Lvl6.ToString();
|
|
dGV_JsonMeter1.Rows[0].Cells[6].Value = regDef.Detail.Privilege.Lvl7.ToString();
|
|
dGV_JsonMeter1.Rows[0].Cells[7].Value = regDef.Detail.Privilege.Lvl8.ToString();
|
|
|
|
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "lB_JsonItems_SelectedIndexChanged() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("JSON file decode failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void JsonAction(bool read, bool write)
|
|
{
|
|
Byte[] temp = new Byte[2];
|
|
|
|
UInt16 MeterNumber = 1;
|
|
if (cB_SerialConfigMassMassLoggingEn.Checked)
|
|
{
|
|
if (rB_JsonMeter1.Checked)
|
|
MeterNumber = 1;
|
|
if (rB_JsonMeter2.Checked)
|
|
MeterNumber = 2;
|
|
if (rB_JsonMeter3.Checked)
|
|
MeterNumber = 3;
|
|
}
|
|
else
|
|
MeterNumber = 1;
|
|
|
|
|
|
try
|
|
{
|
|
FormControl.JsonButtonsDisable(true);
|
|
FormControl.DisableTabExceptJson(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
|
|
Int32 position = lB_JsonItems.SelectedIndex;
|
|
|
|
if (position < 0)
|
|
{
|
|
MessageBox.Show("Select item first", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.JsonButtonsDisable(false);
|
|
FormControl.DisableTabExceptJson(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
return;
|
|
}
|
|
if (position >= 0)
|
|
{
|
|
String Datatype = lJsonDispDataType.Text;
|
|
|
|
DisplayOnTab = (Int32)SelectedTab.Json;
|
|
|
|
RegisterDefinition tempReg = new RegisterDefinition();
|
|
|
|
|
|
if (write)
|
|
{
|
|
String InputData = rTB_JsonWrite.Text;
|
|
Boolean InputDataValid = false;
|
|
|
|
#region Data to write
|
|
|
|
InputData = InputData.ToUpper();
|
|
InputDataValid = Misc.OnlyHexInString(InputData);
|
|
if (!InputDataValid)
|
|
{
|
|
MessageBox.Show("Data is no valid HEX-String", "Form closing", MessageBoxButtons.OK,
|
|
MessageBoxIcon.Error);
|
|
FormControl.JsonButtonsDisable(false);
|
|
FormControl.DisableTabExceptJson(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
return;
|
|
}
|
|
|
|
if (!Int32.Equals(InputData.Count(), 8))
|
|
InputDataValid = false;
|
|
if (!InputDataValid)
|
|
{
|
|
MessageBox.Show("Illegal data length", "Form closing", MessageBoxButtons.OK,
|
|
MessageBoxIcon.Error);
|
|
FormControl.JsonButtonsDisable(false);
|
|
FormControl.DisableTabExceptJson(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
return;
|
|
}
|
|
|
|
UInt32 tempInput = UInt32.Parse(InputData, NumberStyles.AllowHexSpecifier);
|
|
|
|
var Data = BitConverter.GetBytes(tempInput);
|
|
Data = Data.ToArray();
|
|
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(MeterNumber),
|
|
lB_JsonItems.SelectedItem.ToString(), Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK,
|
|
MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK,
|
|
MessageBoxIcon.Error);
|
|
|
|
FormControl.JsonButtonsDisable(false);
|
|
FormControl.DisableTabExceptJson(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
|
|
});
|
|
#endregion
|
|
}
|
|
else if (read)
|
|
{
|
|
var jobToDo = ReadRegister(CheckMeterConnected(MeterNumber), lB_JsonItems.SelectedItem.ToString());
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
temp = resTask.Result;
|
|
FormControl.JsonButtonsDisable(false);
|
|
FormControl.DisableTabExceptJson(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show("Data type is not supported", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.JsonButtonsDisable(false);
|
|
FormControl.DisableTabExceptJson(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
}
|
|
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "Json Action failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Action for register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.JsonButtonsDisable(false);
|
|
FormControl.DisableTabExceptJson(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
}
|
|
}
|
|
|
|
private void btn_JsonWrite_Click(object sender, EventArgs e)
|
|
{
|
|
JsonAction(false, true);
|
|
}
|
|
private void btn_JsonRead_Click(object sender, EventArgs e)
|
|
{
|
|
JsonAction(true, false);
|
|
|
|
}
|
|
private void btn_JsonOpen_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean DialogOK = false;
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
#region Open file dialog
|
|
FormControl.JsonButtonsDisable(true);
|
|
FormControl.DisableTabExceptJson(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
if (File.Exists(JsonDataPath))
|
|
DefaultJsonDirectory = Path.GetDirectoryName(JsonDataPath);
|
|
DialogOK = Files.OpenFileDialogJson(ref JsonDataPath, DefaultJsonDirectory);
|
|
#endregion
|
|
#region Get and decode data
|
|
if (DialogOK)
|
|
{
|
|
lB_JsonItems.Items.Clear();
|
|
var resultAsText = File.ReadAllText(JsonDataPath);
|
|
|
|
//why using comments in a JSON file?! bad implementation!
|
|
//remove comments from String
|
|
resultAsText = resultAsText.Replace("\"_comment\": \"end of table\"", "");
|
|
resultAsText = resultAsText.Replace("\"_comment\": \"Auto generated from 'Configuration.xls' - DO NOT MANUALLY EDIT THIS TABLE\",", "");
|
|
|
|
//Convert String to Dictionary with key(String) and a RegistersProperties as Value
|
|
|
|
var RegistersPropertiesDic = JsonConvert.DeserializeObject<Dictionary<String, RegDefExtended>>(resultAsText);
|
|
|
|
foreach (var item in RegistersPropertiesDic)
|
|
{
|
|
lB_JsonItems.Items.Add($"{item.Key}\n");
|
|
}
|
|
}
|
|
FormControl.JsonButtonsDisable(false);
|
|
FormControl.DisableTabExceptJson(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_JsonOpen_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("File open failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.JsonButtonsDisable(false);
|
|
FormControl.DisableTabExceptJson(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
}
|
|
}
|
|
|
|
private void btn_JsonClearWindow_Click(object sender, EventArgs e)
|
|
{
|
|
rTB_JsonRxData.Clear();
|
|
}
|
|
#endregion
|
|
|
|
|
|
|
|
#region Settings control elements
|
|
private void btn_ElapsedReset_Click(object sender, EventArgs e)
|
|
{
|
|
WaitForBackgroundWorkers();
|
|
Display.DebugElapsedValuesCounterReset();
|
|
WaitForBackgroundWorkers();
|
|
Display.DebugElapsedReset();
|
|
}
|
|
private void btn_ElapsedToCsv_Click(object sender, EventArgs e)
|
|
{
|
|
String Data = DebugElapsedValuesToCsv();
|
|
String Fullpath = String.Empty;
|
|
Boolean FileDialogOk = false;
|
|
Boolean SavingOk = false;
|
|
|
|
WaitForBackgroundWorkers();
|
|
FileDialogOk = Files.SaveFiledialogCsv("Elapsed values", out Fullpath, DefaultCsvDirectory);
|
|
if (FileDialogOk)
|
|
{
|
|
DefaultCsvDirectory = Path.GetDirectoryName(Fullpath);
|
|
WaitForBackgroundWorkers();
|
|
SavingOk = Files.SaveText(Data, Fullpath, GetGlobalCulture());
|
|
}
|
|
|
|
if ((!SavingOk) && (FileDialogOk))
|
|
MessageBox.Show("Saving failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
#endregion
|
|
|
|
Boolean EnableRawFileOpening = false;
|
|
|
|
|
|
private void FileSplitter(Object sender, EventArgs e)
|
|
{
|
|
|
|
if (cB_Form1UseSplitcounter.Checked)
|
|
{
|
|
if (cB_Form1UseSplitcounter.Checked)
|
|
RawSplitcounter = (Int32)nUD_FileSplit.Value;
|
|
|
|
var t = Task.Run(() =>
|
|
{
|
|
while (RawSplitcounter >= 0)
|
|
{
|
|
Misc.WaitNSeconds(1);
|
|
if (RawLoggingSingleMeterEnable)
|
|
SetLabelUseSplitcounter($"{RawSplitcounter.ToString(GetGlobalCulture())}s");
|
|
else
|
|
{
|
|
SetLabelUseSplitcounter("#####");
|
|
return;
|
|
}
|
|
RawSplitcounter--;
|
|
}
|
|
this.Invoke(new EventHandler(StopAndRestartLogging));
|
|
});
|
|
}
|
|
}
|
|
|
|
private void FileSplitterCsv(Object sender, EventArgs e)
|
|
{
|
|
if (cB_Form1UseSplitcounter.Checked)
|
|
{
|
|
if (cB_Form1UseSplitcounter.Checked)
|
|
CsvSplitcounter = (Int32)nUD_FileSplit.Value;
|
|
|
|
var t = Task.Run(() =>
|
|
{
|
|
while (CsvSplitcounter >= 0)
|
|
{
|
|
Misc.WaitNSeconds(1);
|
|
if (LoggingCsvEn)
|
|
SetLabelUseSplitcounter($"{CsvSplitcounter.ToString(GetGlobalCulture())}s");
|
|
else
|
|
{
|
|
SetLabelUseSplitcounter("#####");
|
|
return;
|
|
}
|
|
CsvSplitcounter--;
|
|
}
|
|
this.Invoke(new EventHandler(StopAndRestartCsv));
|
|
});
|
|
}
|
|
}
|
|
|
|
private void FileSplitterMeter1(Object sender, EventArgs e)
|
|
{
|
|
if (cB_UseSplitcounterMeter1.Checked)
|
|
{
|
|
if (cB_UseSplitcounterMeter1.Checked)
|
|
RawSplitcounterMeter1 = (Int32)nUD_FileSplit.Value;
|
|
|
|
var t = Task.Run(() =>
|
|
{
|
|
while (RawSplitcounterMeter1 >= 0)
|
|
{
|
|
Misc.WaitNSeconds(1);
|
|
if (RawLoggingEnable[Constants.Meter1])
|
|
SetLabelUseSplitcounterMeter1($"{RawSplitcounterMeter1.ToString(GetGlobalCulture())}s");
|
|
else
|
|
{
|
|
SetLabelUseSplitcounterMeter1("#####");
|
|
return;
|
|
}
|
|
RawSplitcounterMeter1--;
|
|
}
|
|
this.Invoke(new EventHandler(StopAndRestartLoggingMeter1));
|
|
});
|
|
}
|
|
}
|
|
|
|
private void FileSplitterMeter2(Object sender, EventArgs e)
|
|
{
|
|
if (cB_UseSplitcounterMeter2.Checked)
|
|
{
|
|
if (cB_UseSplitcounterMeter2.Checked)
|
|
RawSplitcounterMeter2 = (Int32)nUD_FileSplit.Value;
|
|
|
|
var t = Task.Run(() =>
|
|
{
|
|
while (RawSplitcounterMeter2 >= 0)
|
|
{
|
|
Misc.WaitNSeconds(1);
|
|
if (RawLoggingEnable[Constants.Meter2])
|
|
SetLabelUseSplitcounterMeter2($"{RawSplitcounterMeter2.ToString(GetGlobalCulture())}s");
|
|
else
|
|
{
|
|
SetLabelUseSplitcounterMeter2("#####");
|
|
return;
|
|
}
|
|
RawSplitcounterMeter2--;
|
|
}
|
|
this.Invoke(new EventHandler(StopAndRestartLoggingMeter2));
|
|
});
|
|
}
|
|
}
|
|
|
|
private void FileSplitterMeter3(Object sender, EventArgs e)
|
|
{
|
|
if (cB_UseSplitcounterMeter3.Checked)
|
|
{
|
|
if (cB_UseSplitcounterMeter3.Checked)
|
|
RawSplitcounterMeter3 = (Int32)nUD_FileSplit.Value;
|
|
|
|
var t = Task.Run(() =>
|
|
{
|
|
while (RawSplitcounterMeter3 >= 0)
|
|
{
|
|
Misc.WaitNSeconds(1);
|
|
if (RawLoggingEnable[Constants.Meter3])
|
|
SetLabelUseSplitcounterMeter3($"{RawSplitcounterMeter3.ToString(GetGlobalCulture())}s");
|
|
else
|
|
{
|
|
SetLabelUseSplitcounterMeter3("#####");
|
|
return;
|
|
}
|
|
RawSplitcounterMeter3--;
|
|
}
|
|
this.Invoke(new EventHandler(StopAndRestartLoggingMeter3));
|
|
});
|
|
}
|
|
}
|
|
|
|
private void StopAndRestartCsv(Object sender, EventArgs e)
|
|
{
|
|
#region Write raw data to file
|
|
if (LoggingCsvEn)
|
|
{
|
|
LoggingCsvEn = false;
|
|
String temp = CsvDataToLog[Constants.PATH0];
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathCsv + "1.csv"))
|
|
{
|
|
sw.Write(temp);
|
|
}
|
|
temp = CsvDataToLog[Constants.PATH1];
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathCsv + "2.csv"))
|
|
{
|
|
sw.Write(temp);
|
|
}
|
|
temp = CsvDataToLog[Constants.PATH2];
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathCsv + "3.csv"))
|
|
{
|
|
sw.Write(temp);
|
|
}
|
|
|
|
CsvDataToLog[Constants.PATH0] = String.Empty;
|
|
CsvDataToLog[Constants.PATH1] = String.Empty;
|
|
CsvDataToLog[Constants.PATH2] = String.Empty;
|
|
}
|
|
#endregion
|
|
#region Restart logging
|
|
#region Set Filename
|
|
String Directory = Path.GetDirectoryName(SaveDataPathCsv);
|
|
SaveDataPathCsv = $"{Directory}\\{DateTime.Now.ToString(Formats.TxtFileDateTimeString, GetGlobalCulture())}GENESIS_CSV_PATH";
|
|
|
|
#endregion
|
|
using (StreamWriter sw = File.CreateText(@SaveDataPathCsv + "1.csv")) { };
|
|
using (StreamWriter sw = File.CreateText(@SaveDataPathCsv + "2.csv")) { };
|
|
using (StreamWriter sw = File.CreateText(@SaveDataPathCsv + "3.csv")) { };
|
|
LoggingCsvEn = true;
|
|
this.Invoke(new EventHandler(FileSplitterCsv));
|
|
#endregion
|
|
}
|
|
|
|
private void StopAndRestartLogging(Object sender, EventArgs e)
|
|
{
|
|
#region Write raw data to file
|
|
if (RawLoggingSingleMeterEnable)
|
|
{
|
|
RawLoggingSingleMeterEnable = false;
|
|
String temp = DataToLog[Constants.Meter1];
|
|
|
|
//Task.Run(() =>
|
|
//{
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathRaw))
|
|
{
|
|
sw.Write(temp);
|
|
}
|
|
//});
|
|
|
|
DataToLog[Constants.Meter1] = String.Empty;
|
|
}
|
|
#endregion
|
|
#region Restart logging
|
|
#region Set Filename
|
|
String Directory = Path.GetDirectoryName(SaveDataPathRaw);
|
|
SaveDataPathRaw = $"{Directory}\\{DateTime.Now.ToString(Formats.TxtFileDateTimeString, GetGlobalCulture())}GENESIS_RAW.txt";
|
|
#endregion
|
|
using (StreamWriter sw = File.CreateText(@SaveDataPathRaw)) { };
|
|
RawLoggingSingleMeterEnable = true;
|
|
this.Invoke(new EventHandler(FileSplitter));
|
|
#endregion
|
|
}
|
|
private void StopAndRestartLoggingMeter1(Object sender, EventArgs e)
|
|
{
|
|
#region Write raw data to file
|
|
if (RawLoggingEnable[Constants.Meter1])
|
|
{
|
|
RawLoggingEnable[Constants.Meter1] = false;
|
|
String temp = DataToLog[Constants.Meter1];
|
|
|
|
//Task.Run(() =>
|
|
//{
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathMeter1))
|
|
{
|
|
sw.Write(temp);
|
|
}
|
|
//});
|
|
|
|
DataToLog[Constants.Meter1] = String.Empty;
|
|
}
|
|
#endregion
|
|
#region Restart logging
|
|
#region Set Filename
|
|
String Directory = Path.GetDirectoryName(SaveDataPathMeter1);
|
|
SaveDataPathMeter1 = Directory + "\\" + DateTime.Now.ToString(Formats.TxtFileDateTimeString, GetGlobalCulture()) + "GENESIS_RAW_METER1.txt";
|
|
#endregion
|
|
using (StreamWriter sw = File.CreateText(@SaveDataPathMeter1)) { };
|
|
RawLoggingEnable[Constants.Meter1] = true;
|
|
this.Invoke(new EventHandler(FileSplitterMeter1));
|
|
#endregion
|
|
}
|
|
private void StopAndRestartLoggingMeter2(Object sender, EventArgs e)
|
|
{
|
|
#region Write raw data to file
|
|
if (RawLoggingEnable[Constants.Meter2])
|
|
{
|
|
RawLoggingEnable[Constants.Meter2] = false;
|
|
String temp = DataToLog[Constants.Meter2];
|
|
|
|
//Task.Run(() =>
|
|
//{
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathMeter2))
|
|
{
|
|
sw.Write(temp);
|
|
}
|
|
//});
|
|
|
|
DataToLog[Constants.Meter2] = String.Empty;
|
|
}
|
|
#endregion
|
|
#region Restart logging
|
|
#region Set Filename
|
|
String Directory = Path.GetDirectoryName(SaveDataPathMeter2);
|
|
SaveDataPathMeter2 = Directory + "\\" + DateTime.Now.ToString(Formats.TxtFileDateTimeString, GetGlobalCulture()) + "GENESIS_RAW_METER2.txt";
|
|
#endregion
|
|
using (StreamWriter sw = File.CreateText(@SaveDataPathMeter2)) { };
|
|
RawLoggingEnable[Constants.Meter2] = true;
|
|
this.Invoke(new EventHandler(FileSplitterMeter2));
|
|
#endregion
|
|
}
|
|
private void StopAndRestartLoggingMeter3(Object sender, EventArgs e)
|
|
{
|
|
#region Write raw data to file
|
|
if (RawLoggingEnable[Constants.Meter3])
|
|
{
|
|
RawLoggingEnable[Constants.Meter3] = false;
|
|
String temp = DataToLog[Constants.Meter3];
|
|
|
|
//Task.Run(() =>
|
|
//{
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathMeter3))
|
|
{
|
|
sw.Write(temp);
|
|
}
|
|
//});
|
|
|
|
DataToLog[Constants.Meter3] = String.Empty;
|
|
}
|
|
#endregion
|
|
#region Restart logging
|
|
#region Set Filename
|
|
String Directory = Path.GetDirectoryName(SaveDataPathMeter3);
|
|
SaveDataPathMeter3 = $"{Directory}\\{DateTime.Now.ToString(Formats.TxtFileDateTimeString, GetGlobalCulture())}GENESIS_RAW_METER3.txt";
|
|
#endregion
|
|
using (StreamWriter sw = File.CreateText(@SaveDataPathMeter3)) { };
|
|
RawLoggingEnable[Constants.Meter3] = true;
|
|
this.Invoke(new EventHandler(FileSplitterMeter3));
|
|
#endregion
|
|
}
|
|
private void SetDialogRaw(String defaultLogDirectory)
|
|
{
|
|
Boolean RawDialogOK = false;
|
|
|
|
if (InvokeRequired)
|
|
{
|
|
Invoke((Action<String>)SetDialogRaw, defaultLogDirectory);
|
|
return;
|
|
}
|
|
|
|
RawDialogOK = Files.SaveFiledialogTxt("RAW", out SaveDataPathRaw, defaultLogDirectory);
|
|
}
|
|
|
|
private void btn_Graph_OpenRaw_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
CultureInfo Culture = GetGlobalCulture();
|
|
Int32 xRange = (Int32)nUD_SettingsXMainGraph.Value;
|
|
Int32 TotalNumberOfValues = (Int32)GraphCounterDataMainTotal[Constants.PATH2];
|
|
Int32 XScaleMin = (Int32)Math.Round(zGC_MainGraph.GraphPane.XAxis.Scale.Min, 0);
|
|
Int32 XScaleMax = (Int32)Math.Round(zGC_MainGraph.GraphPane.XAxis.Scale.Max, 0);
|
|
DecodedData[] DecodingResult = DecodedDataHelper.getDefaultDecodedDataArray(3);
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
DecodingResult[Path] = new DecodedData();
|
|
String Fullpath = String.Empty;
|
|
String Data = String.Empty;
|
|
Boolean FileDialogOK = false;
|
|
Boolean OpeningOK = false;
|
|
Int32 GcCounter = 0;
|
|
Int32 End = 0;
|
|
Int32 ErrorLogPosition = 0;
|
|
Boolean[] PathSelected = new Boolean[Constants.NumberOfPaths] { cB_GraphOptionEnPath0.Checked, cB_GraphOptionEnPath1.Checked, cB_GraphOptionEnPath2.Checked };
|
|
String SelectedGraphOption = lB_Graph_SelectGraph.Text;
|
|
String line = String.Empty;
|
|
#endregion
|
|
#region File dialog
|
|
EnableRawFileOpening = true;
|
|
FileDialogOK = Files.OpenFileDialogText(out Fullpath, DefaultLogDirectory);
|
|
if (FileDialogOK)
|
|
{
|
|
DefaultLogDirectory = Path.GetDirectoryName(Fullpath);
|
|
OpeningOK = Files.OpenText(out Data, Fullpath, Culture);
|
|
}
|
|
#endregion
|
|
if ((!OpeningOK) && (FileDialogOK))
|
|
MessageBox.Show("Opening failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
else
|
|
{
|
|
#region Disable normal graph
|
|
btn_Graph_Abort.Enabled = true;
|
|
btn_Graph_OpenRaw.Enabled = false;
|
|
//Maingraph1.Reset((Double)nUD_SettingsXMainGraph.Value);
|
|
//Maingraph1.InitParameters((Double)nUD_SettingsXMainGraph.Value, lB_Graph_SelectGraph.Text, cB_MultihitOverallAvgEn.Checked, (Int32)nUD_SettingsStdDev.Value, (Int32)nUD_SettingsMean.Value);
|
|
//Maingraph1.InitGraph();
|
|
cB_GraphReset.Enabled = false;
|
|
lB_Graph_SelectGraph.Enabled = false;
|
|
zGC_MainGraph.IsShowHScrollBar = false;
|
|
gB_SettingsMaingraph.Enabled = false;
|
|
#endregion
|
|
|
|
|
|
if (SelectedGraphOption.Contains("Standard"))
|
|
{
|
|
StdDeviationCalculate.Reset(ref TelegramCounterStdDeviationMultihit, ref TelegramCounterStdDeviationSingle, ref ProcessingStdDeviation, ref Processing3HitsStdDeviation, ref Processing8HitsStdDeviation);
|
|
}
|
|
if (SelectedGraphOption.Contains("Mean"))
|
|
{
|
|
pB_MainGraphPrepareData.Maximum = (Int32)nUD_SettingsMean.Value;
|
|
pB_MainGraphPrepareData.Visible = true;
|
|
l_MainGraphPrepareData.Visible = true;
|
|
MeanCalculate.ResetCounters(ref TelegramCounterTofMean, ref TelegramCounterDifTofMean, ref TelegramCounterMultiHitMean, ref TelegramCounterOthersMean, ref TelegramCounterTemperatureMean, ref TelegramCounterFlowMean);
|
|
MeanCalculate.ResetProcessingListsTof(ref ProcessingTofUpMean, ref ProcessingTofDownMean, ref ProcessingDifTofMean);
|
|
}
|
|
else
|
|
{
|
|
pB_MainGraphPrepareData.Visible = false;
|
|
l_MainGraphPrepareData.Visible = false;
|
|
}
|
|
|
|
try
|
|
{
|
|
#region All not mean values except temperature and flow
|
|
if ((!SelectedGraphOption.Contains("Mean")) && (!SelectedGraphOption.Contains("Temperature") && (!SelectedGraphOption.Contains("Flow"))))
|
|
{
|
|
while (End != -1 && EnableRawFileOpening)
|
|
{
|
|
ErrorLogPosition = 1;
|
|
#region Garbage collector
|
|
Misc.GarbageCollector(ref GcCounter);
|
|
#endregion
|
|
#region Prepare data
|
|
End = Data.IndexOf("\n");
|
|
if (int.Equals(End, -1))
|
|
break;
|
|
|
|
line = Data.Substring(0, End - 1);
|
|
Data = Data.Substring(End + 1);
|
|
#endregion
|
|
#region Decode and assign to graph
|
|
if (Boolean.Equals(line.StartsWith("H"), false))
|
|
{
|
|
line = line.Substring(Message.ProtocolIdentPosition);
|
|
|
|
if (line.StartsWith("d V"))
|
|
{
|
|
DecodingResult = DecodeTelegram.DecodedDataDecodeTelegram(line, cB_StdDevEnable.Checked, cB_MeanValuesEnable.Checked, DecodingResult, Constants.NominalFrequency);
|
|
UInt16 Path = DecodingResult[Constants.PATH0].Path;
|
|
//Maingraph1.AssignData(DecodingResult, Path, ref GraphCounterDataMainTotal, ref GraphIndexOfLists);
|
|
}
|
|
else
|
|
{
|
|
if (line.StartsWith("d H"))
|
|
DecodingResult = DecodeTelegram.DecodedDataDecodeTelegram(line, cB_StdDevEnable.Checked, cB_MeanValuesEnable.Checked, DecodingResult, Constants.NominalFrequency);
|
|
}
|
|
}
|
|
Misc.WaitNMilliseconds(1);
|
|
#endregion
|
|
}
|
|
goto SkipOptions; // also works without 'goto' if MISRA compliance required
|
|
}
|
|
#endregion
|
|
|
|
#region Temperature
|
|
if (String.Equals(SelectedGraphOption, "Temperature (H-Protocol)"))
|
|
{
|
|
ErrorLogPosition = 5;
|
|
|
|
while (End != -1 && EnableRawFileOpening)
|
|
{
|
|
#region Garbage collector
|
|
Misc.GarbageCollector(ref GcCounter);
|
|
#endregion
|
|
#region Prepare data
|
|
End = Data.IndexOf("\n");
|
|
if (End == -1)
|
|
break;
|
|
|
|
line = Data.Substring(0, End - 1);
|
|
Data = Data.Substring(End + 1);
|
|
#endregion
|
|
#region Decode and assign to graph
|
|
|
|
line = line.Substring(Message.ProtocolIdentPosition);
|
|
|
|
if (line.StartsWith("@h"))
|
|
{
|
|
DecodingResult = DecodeTelegram.DecodedDataDecodeTelegram(line, cB_StdDevEnable.Checked, cB_MeanValuesEnable.Checked, DecodingResult, Constants.NominalFrequency);
|
|
UInt16 Path = DecodingResult[Constants.PATH0].Path;
|
|
//Maingraph1.AssignData(DecodingResult, Path, ref GraphCounterDataMainTotal, ref GraphIndexOfLists);
|
|
}
|
|
//}
|
|
Misc.WaitNMilliseconds(1);
|
|
#endregion
|
|
}
|
|
goto SkipOptions;
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_Graph_OpenRaw_Click() failed", $"0x{ex.HResult.ToString("X", Culture)}", ErrorLogPosition.ToString());
|
|
}
|
|
}
|
|
|
|
SkipOptions:;
|
|
#region End
|
|
cB_GraphReset.Enabled = true;
|
|
lB_Graph_SelectGraph.Enabled = true;
|
|
btn_Graph_Abort.Enabled = false;
|
|
btn_Graph_OpenRaw.Enabled = true;
|
|
gB_SettingsMaingraph.Enabled = true;
|
|
zGC_MainGraph.AutoScroll = true;
|
|
zGC_MainGraph.IsShowHScrollBar = true;
|
|
zGC_MainGraph.IsShowVScrollBar = false;
|
|
zGC_MainGraph.IsEnableZoom = true;
|
|
zGC_MainGraph.SetAutoScrollMargin(0, 0);
|
|
pB_MainGraphPrepareData.Visible = false;
|
|
l_MainGraphPrepareData.Visible = false;
|
|
#endregion
|
|
}
|
|
private void btn_Graph_Abort_Click(object sender, EventArgs e)
|
|
{
|
|
EnableRawFileOpening = false;
|
|
}
|
|
|
|
private void cB_SerialConfigMassMassLoggingEn_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if (!StartUpDisable)
|
|
{
|
|
#region Switch to single logging
|
|
cB_SerialConfigMassLoggingEn.Checked = cB_SerialConfigMassMassLoggingEn.Checked; // Synchronize with checkbox on tab '
|
|
MassLogging = cB_SerialConfigMassMassLoggingEn.Checked;
|
|
|
|
if (Boolean.Equals(cB_SerialConfigMassMassLoggingEn.Checked, false))
|
|
{
|
|
#region Single logging
|
|
gB_ElapsedCalcCycles.Enabled = true;
|
|
tab_Maintab.TabPages.Remove(tab_Logging);
|
|
tab_Maintab.TabPages.Remove(tab_SerialConfigMass);
|
|
tab_Maintab.TabPages.Remove(tab_Gp30SettingsMeter2);
|
|
tab_Maintab.TabPages.Remove(tab_Gp30SettingsMeter3);
|
|
tab_Maintab.TabPages.Insert(2, tab_SerialConfig);
|
|
tab_Maintab.TabPages.Insert(2, tab_RawData);
|
|
//tab_Maintab.TabPages.Insert(2, tab_MeanValues);
|
|
//if(cB_UseIProtocol.Checked == false)
|
|
// tab_Maintab.TabPages.Insert(2, tab_DataDecoding);
|
|
//else
|
|
tab_Maintab.TabPages.Insert(2, tab_DataDecoding2);
|
|
tab_Maintab.TabPages.Insert(2, tab_Graph);
|
|
//tab_Maintab.TabPages.Insert(2, tab_StdDev);
|
|
tab_Maintab.TabPages.Insert(2, tab_Report);
|
|
|
|
tab_GP30SettingsMeter1.Text = "GP30 settings";
|
|
gB_JsonSelectMeter.Visible = false; // radio buttons for meter select
|
|
gB_Form1Logging.Visible = true;
|
|
tab_Maintab.SelectedTab = tab_SerialConfig;
|
|
#endregion
|
|
}
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void cB_SerialConfigMassLoggingEn_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
|
|
if (!StartUpDisable)
|
|
{
|
|
#region Switch to masslogging
|
|
cB_SerialConfigMassMassLoggingEn.Checked = cB_SerialConfigMassLoggingEn.Checked;
|
|
MassLogging = cB_SerialConfigMassLoggingEn.Checked;
|
|
|
|
if (cB_SerialConfigMassLoggingEn.Checked)
|
|
{
|
|
if ((!cB_StdDevEnable.Checked) && (!cB_GraphReset.Checked) && (!cB_MeanValuesEnable.Checked))
|
|
{
|
|
#region Mass logging
|
|
gB_ElapsedCalcCycles.Enabled = false;
|
|
//tab_Maintab.TabPages.Remove(tab_StdDev);
|
|
tab_Maintab.TabPages.Remove(tab_Graph);
|
|
//tab_Maintab.TabPages.Remove(tab_DataDecoding);
|
|
tab_Maintab.TabPages.Remove(tab_DataDecoding2);
|
|
tab_Maintab.TabPages.Remove(tab_RawData);
|
|
//tab_Maintab.TabPages.Remove(tab_MeanValues);
|
|
tab_Maintab.TabPages.Remove(tab_Logging);
|
|
tab_Maintab.TabPages.Remove(tab_SerialConfig);
|
|
tab_Maintab.TabPages.Remove(tab_Report);
|
|
tab_Maintab.TabPages.Insert(2, tab_Logging);
|
|
tab_Maintab.TabPages.Insert(2, tab_SerialConfigMass);
|
|
tab_Maintab.TabPages.Insert(1, tab_Gp30SettingsMeter3);
|
|
tab_Maintab.TabPages.Insert(1, tab_Gp30SettingsMeter2);
|
|
|
|
tab_GP30SettingsMeter1.Text = "GP30 settings METER1";
|
|
gB_JsonSelectMeter.Visible = true; // radio buttons for meter select
|
|
gB_Form1Logging.Visible = false;
|
|
tab_Maintab.SelectedTab = tab_SerialConfigMass;
|
|
#endregion
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
#region Buttons for logging
|
|
private void btn_StartLoggingMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean StartRawLogging = false;
|
|
String Filename = String.Empty;
|
|
String Where = "Start";
|
|
Boolean RawDialogOK = false;
|
|
Boolean IncludeGp30Settings = cB_IncludeGp30SettingsMeter1.Checked;
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
#region Parameter query check
|
|
if (IncludeGp30Settings)
|
|
{
|
|
Where = "Query check";
|
|
WaitForBackgroundWorkers();
|
|
if ((l_GetFirstLevelUpPath0Meter1.Text.Contains("-")) || (l_GetFirstLevelUpPath1Meter1.Text.Contains("-")) || (l_GetFirstLevelUpPath2Meter1.Text.Contains("-")) ||
|
|
(l_GetFirstLevelDownPath0Meter1.Text.Contains("-")) || (l_GetFirstLevelDownPath1Meter1.Text.Contains("-")) || (l_GetFirstLevelDownPath2Meter1.Text.Contains("-")) ||
|
|
(l_Gp30GetAmplitudeMeter1.Text.Contains("-")) || (l_Gp30GetNumberOfPulsesMeter1.Text.Contains("-")) || (l_Gp30GetStartHitMeter1.Text.Contains("-")))
|
|
{
|
|
MessageBox.Show("Perform parameter readout or deselect\n 'Include GP30 Settings'-option", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
return;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Raw file dialog
|
|
Where = "File dialog";
|
|
WaitForBackgroundWorkers();
|
|
RawDialogOK = Files.SaveFiledialogTxt("RAW_METER1", out SaveDataPathMeter1, DefaultLogDirectory);
|
|
#endregion
|
|
#region Save to file
|
|
if (RawDialogOK)
|
|
{
|
|
#region Set default directory
|
|
Where = "Save";
|
|
DefaultLogDirectory = Path.GetDirectoryName(SaveDataPathMeter1);
|
|
#endregion
|
|
#region Create empty file
|
|
WaitForBackgroundWorkers();
|
|
DataToLog[Constants.Meter1] = String.Empty;
|
|
using (StreamWriter sw = File.CreateText(@SaveDataPathMeter1)) { };
|
|
#endregion
|
|
#region Add header
|
|
if (IncludeGp30Settings)
|
|
{
|
|
WaitForBackgroundWorkers();
|
|
String HeaderText =
|
|
$"H First hit up PATH1= {l_GetFirstLevelUpPath0Meter1.Text}\r\nH First hit up PATH2= {l_GetFirstLevelUpPath1Meter1.Text}\r\nH First hit up PATH3= {l_GetFirstLevelUpPath2Meter1.Text}\r\nH First hit down PATH1= {l_GetFirstLevelDownPath0Meter1.Text}\r\nH First hit down PATH2= {l_GetFirstLevelDownPath1Meter1.Text}\r\nH First hit down PATH3= {l_GetFirstLevelDownPath2Meter1.Text}\r\nH Number of bursts= {l_Gp30GetNumberOfPulsesMeter1.Text}\r\nH Starthit= {l_Gp30GetStartHitMeter1.Text}\r\nH Amplitude= {l_Gp30GetAmplitudeMeter1.Text}\r\nH Samplerate= {l_Gp30GetSamplerateMeter1.Text}";
|
|
|
|
WaitForBackgroundWorkers();
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathMeter1))
|
|
{
|
|
sw.WriteLine(HeaderText);
|
|
// sw.Dispose();
|
|
}
|
|
}
|
|
#endregion
|
|
#region Set control elements
|
|
btn_StartLoggingMeter1.Enabled = false;
|
|
btn_StopLoggingMeter1.Enabled = true;
|
|
cB_IncludeGp30SettingsMeter1.Enabled = false;
|
|
cB_SerialConfigMassLoggingEn.Enabled = false; //Checkbox for on tab 'tab_SerialConfig" to switch to mass logging
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = false; //Checkbox for on tab 'tab_SerialConfig" to switch to normal logging
|
|
cB_UseSplitcounterMeter1.Enabled = false;
|
|
#endregion
|
|
#region Set flags
|
|
StartRawLogging = true;
|
|
#endregion
|
|
}
|
|
else
|
|
MessageBox.Show("Raw data dialog error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion;
|
|
#region Set flags
|
|
RawLoggingEnable[Constants.Meter1] = StartRawLogging;
|
|
#endregion
|
|
#region Filesplitter
|
|
Where = "Filesplitter";
|
|
|
|
if (RawLoggingEnable[Constants.Meter1])
|
|
{
|
|
this.Invoke(new EventHandler(FileSplitterMeter1));
|
|
}
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_StartLoggingMeter1_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", Where);
|
|
MessageBox.Show("Logging error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_StartLoggingMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean StartRawLogging = false;
|
|
String Filename = String.Empty;
|
|
String ErrorLogParam = "0";
|
|
Boolean RawDialogOK = false;
|
|
Boolean IncludeGp30Settings = cB_IncludeGp30SettingsMeter2.Checked;
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
#region Parameter query check
|
|
if (IncludeGp30Settings)
|
|
{
|
|
ErrorLogParam = "1";
|
|
WaitForBackgroundWorkers();
|
|
if ((l_GetFirstLevelUpPath0Meter2.Text.Contains("-")) || (l_GetFirstLevelUpPath1Meter2.Text.Contains("-")) || (l_GetFirstLevelUpPath2Meter2.Text.Contains("-")) ||
|
|
(l_GetFirstLevelDownPath0Meter2.Text.Contains("-")) || (l_GetFirstLevelDownPath1Meter2.Text.Contains("-")) || (l_GetFirstLevelDownPath2Meter2.Text.Contains("-")) ||
|
|
(l_Gp30GetAmplitudeMeter2.Text.Contains("-")) || (l_Gp30GetNumberOfPulsesMeter2.Text.Contains("-")) || (l_Gp30GetStartHitMeter2.Text.Contains("-")))
|
|
{
|
|
MessageBox.Show("Perform parameter readout or deselect\n 'Include GP30 Settings'-option", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
return;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Raw file dialog
|
|
ErrorLogParam = "2";
|
|
WaitForBackgroundWorkers();
|
|
RawDialogOK = Files.SaveFiledialogTxt("RAW_METER2", out SaveDataPathMeter2, DefaultLogDirectory);
|
|
#endregion
|
|
#region Save to file
|
|
ErrorLogParam = "3";
|
|
if (RawDialogOK)
|
|
{
|
|
#region Set default directory
|
|
DefaultLogDirectory = Path.GetDirectoryName(SaveDataPathMeter2);
|
|
#endregion
|
|
#region Create empty file
|
|
WaitForBackgroundWorkers();
|
|
DataToLog[Constants.Meter2] = String.Empty;
|
|
using (StreamWriter sw = File.CreateText(@SaveDataPathMeter2)) { };
|
|
#endregion
|
|
#region Add header
|
|
if (IncludeGp30Settings)
|
|
{
|
|
WaitForBackgroundWorkers();
|
|
String HeaderText = $"H First hit up PATH1= {l_GetFirstLevelUpPath0Meter2.Text}\r\nH First hit up PATH2= {l_GetFirstLevelUpPath1Meter2.Text}\r\nH First hit up PATH3= {l_GetFirstLevelUpPath2Meter2.Text}\r\nH First hit down PATH1= {l_GetFirstLevelDownPath0Meter2.Text}\r\nH First hit down PATH2= {l_GetFirstLevelDownPath1Meter2.Text}\r\nH First hit down PATH3= {l_GetFirstLevelDownPath2Meter2.Text}\r\nH Number of bursts= {l_Gp30GetNumberOfPulsesMeter2.Text}\r\nH Starthit= {l_Gp30GetStartHitMeter2.Text}\r\nH Amplitude= {l_Gp30GetAmplitudeMeter2.Text}\r\nH Samplerate= {l_Gp30GetSamplerateMeter2.Text}";
|
|
|
|
WaitForBackgroundWorkers();
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathMeter2))
|
|
{
|
|
sw.WriteLine(HeaderText);
|
|
// sw.Dispose();
|
|
}
|
|
}
|
|
#endregion
|
|
#region Set flags
|
|
StartRawLogging = true;
|
|
#endregion
|
|
}
|
|
else
|
|
MessageBox.Show("Raw data dialog error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion;
|
|
#region Set control elements
|
|
btn_StartLoggingMeter2.Enabled = false;
|
|
btn_StopLoggingMeter2.Enabled = true;
|
|
cB_IncludeGp30SettingsMeter2.Enabled = false;
|
|
cB_SerialConfigMassLoggingEn.Enabled = false; //Checkbox for on tab 'tab_SerialConfig" to switch to mass logging
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = false; //Checkbox for on tab 'tab_SerialConfig" to switch to normal logging
|
|
cB_UseSplitcounterMeter2.Enabled = false;
|
|
#endregion
|
|
#region Set flags
|
|
RawLoggingEnable[Constants.Meter2] = StartRawLogging;
|
|
#endregion
|
|
#region Filesplitter
|
|
if (RawLoggingEnable[Constants.Meter2])
|
|
{
|
|
this.Invoke(new EventHandler(FileSplitterMeter2));
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_StartLoggingMeter2_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", ErrorLogParam);
|
|
MessageBox.Show("Logging error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_StartLoggingMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean StartRawLogging = false;
|
|
String Filename = String.Empty;
|
|
String ErrorLogParam = "0";
|
|
Boolean RawDialogOK = false;
|
|
Boolean IncludeGp30Settings = cB_IncludeGp30SettingsMeter3.Checked;
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
#region Parameter query check
|
|
if (IncludeGp30Settings)
|
|
{
|
|
ErrorLogParam = "1";
|
|
WaitForBackgroundWorkers();
|
|
if ((l_GetFirstLevelUpPath0Meter3.Text.Contains("-")) || (l_GetFirstLevelUpPath1Meter3.Text.Contains("-")) || (l_GetFirstLevelUpPath2Meter3.Text.Contains("-")) ||
|
|
(l_GetFirstLevelDownPath0Meter3.Text.Contains("-")) || (l_GetFirstLevelDownPath1Meter3.Text.Contains("-")) || (l_GetFirstLevelDownPath2Meter3.Text.Contains("-")) ||
|
|
(l_Gp30GetAmplitudeMeter3.Text.Contains("-")) || (l_Gp30GetNumberOfPulsesMeter3.Text.Contains("-")) || (l_Gp30GetStartHitMeter3.Text.Contains("-")))
|
|
{
|
|
MessageBox.Show("Perform parameter readout or deselect\n 'Include GP30 Settings'-option", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
return;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Raw file dialog
|
|
ErrorLogParam = "2";
|
|
WaitForBackgroundWorkers();
|
|
RawDialogOK = Files.SaveFiledialogTxt("RAW_METER3", out SaveDataPathMeter3, DefaultLogDirectory);
|
|
#endregion
|
|
#region Save to file
|
|
ErrorLogParam = "3";
|
|
if (RawDialogOK)
|
|
{
|
|
#region Set default directory
|
|
DefaultLogDirectory = Path.GetDirectoryName(SaveDataPathMeter3);
|
|
#endregion
|
|
#region Create empty file
|
|
WaitForBackgroundWorkers();
|
|
DataToLog[Constants.Meter3] = String.Empty;
|
|
using (StreamWriter sw = File.CreateText(@SaveDataPathMeter3)) { };
|
|
#endregion
|
|
#region Add header
|
|
if (IncludeGp30Settings)
|
|
{
|
|
WaitForBackgroundWorkers();
|
|
String HeaderText = $"H First hit up PATH1= {l_GetFirstLevelUpPath0Meter3.Text}\r\nH First hit up PATH2= {l_GetFirstLevelUpPath1Meter3.Text}\r\nH First hit up PATH3= {l_GetFirstLevelUpPath2Meter3.Text}\r\nH First hit down PATH1= {l_GetFirstLevelDownPath0Meter3.Text}\r\nH First hit down PATH2= {l_GetFirstLevelDownPath1Meter3.Text}\r\nH First hit down PATH3= {l_GetFirstLevelDownPath2Meter3.Text}\r\nH Number of bursts= {l_Gp30GetNumberOfPulsesMeter3.Text}\r\nH Starthit= {l_Gp30GetStartHitMeter3.Text}\r\nH Amplitude= {l_Gp30GetAmplitudeMeter3.Text}\r\nH Samplerate= {l_Gp30GetSamplerateMeter3.Text}";
|
|
|
|
WaitForBackgroundWorkers();
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathMeter3))
|
|
{
|
|
sw.WriteLine(HeaderText);
|
|
// sw.Dispose();
|
|
}
|
|
}
|
|
#endregion
|
|
#region Set flags
|
|
StartRawLogging = true;
|
|
#endregion
|
|
}
|
|
else
|
|
MessageBox.Show("Raw data dialog error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion;
|
|
#region Set control elements
|
|
btn_StartLoggingMeter3.Enabled = false;
|
|
btn_StopLoggingMeter3.Enabled = true;
|
|
cB_IncludeGp30SettingsMeter3.Enabled = false;
|
|
cB_SerialConfigMassLoggingEn.Enabled = false; //Checkbox for on tab 'tab_SerialConfig" to switch to mass logging
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = false; //Checkbox for on tab 'tab_SerialConfig" to switch to normal logging
|
|
cB_UseSplitcounterMeter3.Enabled = false;
|
|
#endregion
|
|
#region Set flags
|
|
RawLoggingEnable[Constants.Meter3] = StartRawLogging;
|
|
#endregion
|
|
#region Filesplitter
|
|
if (RawLoggingEnable[Constants.Meter3])
|
|
{
|
|
this.Invoke(new EventHandler(FileSplitterMeter3));
|
|
}
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_StartLoggingMeter3_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", ErrorLogParam);
|
|
MessageBox.Show("Logging error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_StopLoggingMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
#region Set control elements
|
|
btn_StartLoggingMeter1.Enabled = true;
|
|
btn_StopLoggingMeter1.Enabled = false;
|
|
cB_IncludeGp30SettingsMeter1.Enabled = true;
|
|
cB_UseSplitcounterMeter1.Enabled = true;
|
|
if ((Boolean.Equals(RawLoggingEnable[Constants.Meter2], false)) && (Boolean.Equals(RawLoggingEnable[Constants.Meter3], false)))
|
|
{
|
|
cB_SerialConfigMassLoggingEn.Enabled = true; //Checkbox for on tab 'tab_SerialConfig" to switch to mass logging
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = true; //Checkbox for on tab 'tab_SerialConfig" to switch to normal logging
|
|
}
|
|
#endregion
|
|
#region Write raw data to file
|
|
if (RawLoggingEnable[Constants.Meter1])
|
|
{
|
|
RawLoggingEnable[Constants.Meter1] = false;
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathMeter1))
|
|
{
|
|
sw.Write(DataToLog[Constants.Meter1]);
|
|
}
|
|
}
|
|
DataToLog[Constants.Meter1] = String.Empty;
|
|
#endregion
|
|
}
|
|
|
|
private void btn_StopLoggingMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
#region Set control elements
|
|
btn_StartLoggingMeter2.Enabled = true;
|
|
btn_StopLoggingMeter2.Enabled = false;
|
|
cB_IncludeGp30SettingsMeter2.Enabled = true;
|
|
cB_UseSplitcounterMeter2.Enabled = true;
|
|
if ((RawLoggingEnable[Constants.Meter1] == false) && (RawLoggingEnable[Constants.Meter3] == false))
|
|
{
|
|
cB_SerialConfigMassLoggingEn.Enabled = true; //Checkbox for on tab 'tab_SerialConfig" to switch to mass logging
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = true; //Checkbox for on tab 'tab_SerialConfig" to switch to normal logging
|
|
}
|
|
#endregion
|
|
#region Write raw data to file
|
|
if (RawLoggingEnable[Constants.Meter2])
|
|
{
|
|
RawLoggingEnable[Constants.Meter2] = false;
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathMeter2))
|
|
sw.Write(DataToLog[Constants.Meter2]);
|
|
}
|
|
DataToLog[Constants.Meter2] = String.Empty;
|
|
#endregion
|
|
}
|
|
|
|
private void btn_StopLoggingMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
#region Set control elements
|
|
btn_StartLoggingMeter3.Enabled = true;
|
|
btn_StopLoggingMeter3.Enabled = false;
|
|
cB_UseSplitcounterMeter3.Enabled = true;
|
|
cB_IncludeGp30SettingsMeter3.Enabled = true;
|
|
if ((RawLoggingEnable[Constants.Meter1] == false) && (RawLoggingEnable[Constants.Meter2] == false))
|
|
{
|
|
cB_SerialConfigMassLoggingEn.Enabled = true; //Checkbox for on tab 'tab_SerialConfig" to switch to mass logging
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = true; //Checkbox for on tab 'tab_SerialConfig" to switch to normal logging
|
|
}
|
|
#endregion
|
|
#region Write raw data to file
|
|
if (RawLoggingEnable[Constants.Meter3])
|
|
{
|
|
RawLoggingEnable[Constants.Meter3] = false;
|
|
using (StreamWriter sw = File.AppendText(@SaveDataPathMeter3))
|
|
{
|
|
sw.Write(DataToLog[Constants.Meter3]);
|
|
}
|
|
}
|
|
DataToLog[Constants.Meter3] = String.Empty;
|
|
#endregion
|
|
|
|
}
|
|
#endregion
|
|
|
|
|
|
|
|
#region Buttons serial config
|
|
private void btn_SerialCfgMass_CmdMeter1Open_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
|
|
//try
|
|
//{
|
|
#region Open serial port
|
|
WaitForBackgroundWorkers();
|
|
|
|
currentMeter = new GenesisMeter();
|
|
// to do add selection for slot selection
|
|
|
|
currentMeter.SetupFromConfigFile(1, false);
|
|
GlobalMeterBatch.AddMeter(currentMeter);
|
|
currentMeter.OnRequestRecordReceived += CurrentMeter_OnRequestdataRecived;
|
|
//Ok = SerialPortCmdMeter1Open(MassLogging);
|
|
//if (!Ok)
|
|
// return;
|
|
//CommandInterface1.Init(Constants.Meter1, serialPortCmdMeter1);
|
|
#endregion
|
|
#region Serial config elements
|
|
WaitForBackgroundWorkers();
|
|
#region On tab 'serial port configuration'
|
|
btn_SerialCfg_CmdOpen.Enabled = false;
|
|
btn_SerialCfg_CmdClose.Enabled = true;
|
|
|
|
l_SerialCfg_CmdComSelect.Enabled = false;
|
|
lB_SerialCfg_CmdChannel.Enabled = false;
|
|
#endregion
|
|
#region On tab 'serial port configuration (mass)'
|
|
btn_SerialCfgMass_CmdMeter1Open.Enabled = false;
|
|
btn_SerialCfgMass_CmdMeter1Close.Enabled = true;
|
|
btn_SerialCfgMass_CmdMeter1Inhibit.Enabled = true;
|
|
|
|
l_SerialCfgMass_CmdMeter1ComSelect.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter1ComSelect.Enabled = false;
|
|
l_SerialCfgMass_CmdMeter1Baudrate.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter1Baudrate.Enabled = false;
|
|
l_SerialCfgMass_CmdMeter1Databits.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter1Databits.Enabled = false;
|
|
l_SerialCfgMass_CmdMeter1Stopbits.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter1Stopbits.Enabled = false;
|
|
l_SerialCfgMass_CmdMeter1Parity.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter1Parity.Enabled = false;
|
|
l_SerialCfgMass_CmdMeter1Handshake.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter1Handshake.Enabled = false;
|
|
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = false; // Mass logging check box
|
|
#endregion
|
|
#region Synchronize selected items
|
|
lB_SerialCfg_CmdChannel.SelectedIndex = lB_SerialCfgMass_CmdMeter1ComSelect.SelectedIndex;
|
|
#endregion
|
|
#endregion
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfgMass_CmdMeter1Open_Click() failed", "0x" + ex.HResult.ToString("X", GetGlobalCulture()), String.Empty);
|
|
// MessageBox.Show("Serial port could not be opened", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
//// }
|
|
}
|
|
|
|
private void btn_SerialCfgMass_CmdMeter1Inhibit_Click(object sender, EventArgs e)
|
|
{
|
|
Boolean Ok = false;
|
|
CultureInfo Culture = GetGlobalCulture();
|
|
|
|
try
|
|
{
|
|
#region Serial port inhibit
|
|
Ok = SerialPortInhibit(ref serialPortCmdMeter1, Constants.CmdMeter1);
|
|
if (!Ok)
|
|
return;
|
|
CommandInterface1.Init(Constants.Meter1, serialPortCmdMeter1, Culture);
|
|
#endregion
|
|
#region On tab 'serial port configuration'
|
|
btn_SerialCfg_CmdOpen.Enabled = true;
|
|
btn_SerialCfg_CmdOpen.Text = "Serial Port Enable";
|
|
btn_SerialCfg_CmdClose.Enabled = false;
|
|
#endregion
|
|
#region On tab 'serial port configuration (mass)'
|
|
btn_SerialCfgMass_CmdMeter1Open.Enabled = true;
|
|
btn_SerialCfgMass_CmdMeter1Open.Text = "Serial Port Enable";
|
|
btn_SerialCfgMass_CmdMeter1Close.Enabled = false;
|
|
btn_SerialCfgMass_CmdMeter1Inhibit.Enabled = false;
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfgMass_CmdMeter1Inhibit() failed", $"0x{ex.HResult.ToString("X", Culture)}", String.Empty);
|
|
MessageBox.Show("Unknown error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SerialCfgMass_CmdMeter1Close_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean Ok = false;
|
|
String DebugMessage = String.Empty;
|
|
CultureInfo Culture = GetGlobalCulture();
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
#region Serial port close
|
|
Ok = SerialPortClose(ref serialPortCmdMeter1, Constants.CmdMeter1, out DebugMessage);
|
|
if (!Ok)
|
|
{
|
|
MessageBox.Show(DebugMessage, "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
return;
|
|
}
|
|
CommandInterface1.Init(Constants.Meter1, serialPortCmdMeter1, Culture);
|
|
#endregion
|
|
#region On tab 'serial port configuraton'
|
|
btn_SerialCfg_CmdOpen.Enabled = true;
|
|
btn_SerialCfg_CmdOpen.Text = "Serial Port Open";
|
|
btn_SerialCfg_CmdClose.Enabled = false;
|
|
|
|
l_SerialCfg_CmdComSelect.Enabled = true;
|
|
lB_SerialCfg_CmdChannel.Enabled = true;
|
|
#endregion
|
|
#region On tab 'serial port configuration (mass)'
|
|
btn_SerialCfgMass_CmdMeter1Open.Enabled = true;
|
|
btn_SerialCfgMass_CmdMeter1Open.Text = "Serial Port Open";
|
|
btn_SerialCfgMass_CmdMeter1Close.Enabled = false;
|
|
btn_SerialCfgMass_CmdMeter1Inhibit.Enabled = false;
|
|
|
|
l_SerialCfgMass_CmdMeter1ComSelect.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter1ComSelect.Enabled = true;
|
|
l_SerialCfgMass_CmdMeter1Baudrate.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter1Baudrate.Enabled = true;
|
|
l_SerialCfgMass_CmdMeter1Databits.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter1Databits.Enabled = true;
|
|
l_SerialCfgMass_CmdMeter1Stopbits.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter1Stopbits.Enabled = true;
|
|
l_SerialCfgMass_CmdMeter1Parity.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter1Parity.Enabled = true;
|
|
l_SerialCfgMass_CmdMeter1Handshake.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter1Handshake.Enabled = true;
|
|
if ((serialPortCmdMeter2.IsOpen == false) &&
|
|
(serialPortCmdMeter3.IsOpen == false) &&
|
|
(serialPortDataMeter1.IsOpen == false) &&
|
|
(serialPortDataMeter2.IsOpen == false) &&
|
|
(serialPortDataMeter3.IsOpen == false))
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = true; // Mass logging check box
|
|
#endregion
|
|
#region Message box
|
|
MessageBox.Show("Serial Port closed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfgMass_CmdMeter1Close_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Unknown error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SerialCfgMass_CmdMeter2Open_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
#region Open serial port
|
|
WaitForBackgroundWorkers();
|
|
currentMeter = new GenesisMeter();
|
|
// to do add selection for slot selection
|
|
currentMeter.SetupFromConfigFile(2, false);
|
|
GlobalMeterBatch.AddMeter(currentMeter);
|
|
currentMeter.OnRequestRecordReceived += CurrentMeter_OnRequestdataRecived;
|
|
//Ok = SerialPort_CmdMeter2Open(MassLogging);
|
|
//if (!Ok)
|
|
// return;
|
|
//CommandInterface2.Init(Constants.Meter2, serialPortCmdMeter2);
|
|
#endregion
|
|
#region Serial config elements
|
|
WaitForBackgroundWorkers();
|
|
#region On tab 'serial port configuration (mass)'
|
|
btn_SerialCfgMass_CmdMeter2Open.Enabled = false;
|
|
btn_SerialCfgMass_CmdMeter2Close.Enabled = true;
|
|
btn_SerialCfgMass_CmdMeter2Inhibit.Enabled = true;
|
|
|
|
l_SerialCfgMass_CmdMeter2ComSelect.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter2ComSelect.Enabled = false;
|
|
l_SerialCfgMass_CmdMeter2Baudrate.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter2Baudrate.Enabled = false;
|
|
l_SerialCfgMass_CmdMeter2Databits.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter2Databits.Enabled = false;
|
|
l_SerialCfgMass_CmdMeter2Stopbits.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter2Stopbits.Enabled = false;
|
|
l_SerialCfgMass_CmdMeter2Parity.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter2Parity.Enabled = false;
|
|
l_SerialCfgMass_CmdMeter2Handshake.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter2Handshake.Enabled = false;
|
|
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = false; // Mass logging check box
|
|
#endregion
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfgMass_CmdMeter2Open_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Serial port could not be opened", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
|
|
private void btn_SerialCfgMass_CmdMeter3Open_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
try
|
|
{
|
|
#region Open serial port
|
|
WaitForBackgroundWorkers();
|
|
currentMeter = new GenesisMeter();
|
|
// to do add selection for slot selection
|
|
currentMeter.SetupFromConfigFile(3, false);
|
|
GlobalMeterBatch.AddMeter(currentMeter);
|
|
currentMeter.OnRequestRecordReceived += CurrentMeter_OnRequestdataRecived;
|
|
//Ok = SerialPort_CmdMeter3Open(MassLogging);
|
|
//if (!Ok)
|
|
// return;
|
|
//CommandInterface3.Init(Constants.Meter3, serialPortCmdMeter3);
|
|
#endregion
|
|
#region Serial config elements
|
|
WaitForBackgroundWorkers();
|
|
#region On tab 'serial port configuration (mass)'
|
|
btn_SerialCfgMass_CmdMeter3Open.Enabled = false;
|
|
btn_SerialCfgMass_CmdMeter3Close.Enabled = true;
|
|
btn_SerialCfgMass_CmdMeter3Inhibit.Enabled = true;
|
|
|
|
l_SerialCfgMass_CmdMeter3ComSelect.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter3ComSelect.Enabled = false;
|
|
l_SerialCfgMass_CmdMeter3Baudrate.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter3Baudrate.Enabled = false;
|
|
l_SerialCfgMass_CmdMeter3Databits.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter3Databits.Enabled = false;
|
|
l_SerialCfgMass_CmdMeter3Stopbits.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter3Stopbits.Enabled = false;
|
|
l_SerialCfgMass_CmdMeter3Parity.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter3Parity.Enabled = false;
|
|
l_SerialCfgMass_CmdMeter3Handshake.Enabled = false;
|
|
lB_SerialCfgMass_CmdMeter3Handshake.Enabled = false;
|
|
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = false; // Mass logging check box
|
|
#endregion
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfgMass_CmdMeter3Open_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Serial port could not be opened", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
|
|
private void CurrentMeter_OnRequestRecordReceived1(object sender, Xylem.Common.Hardware.WaterMeter.Genesis.DataPackages.EventArguments.RequestResponseDataEventArgs e)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
private void CurrentMeter_OnRequestRecordReceived(object sender, Xylem.Common.Hardware.WaterMeter.Genesis.DataPackages.EventArguments.RequestResponseDataEventArgs e)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
private void btn_SerialCfgMass_CmdMeter2Inhibit_Click(object sender, EventArgs e)
|
|
{
|
|
Boolean Ok = false;
|
|
CultureInfo Culture = GetGlobalCulture();
|
|
try
|
|
{
|
|
#region Serial port inhibit
|
|
Ok = SerialPortInhibit(ref serialPortCmdMeter2, Constants.CmdMeter2);
|
|
if (!Ok)
|
|
return;
|
|
CommandInterface2.Init(Constants.Meter2, serialPortCmdMeter2, Culture);
|
|
#endregion
|
|
#region On tab 'serial port configuration (mass)'
|
|
btn_SerialCfgMass_CmdMeter2Open.Enabled = true;
|
|
btn_SerialCfgMass_CmdMeter2Open.Text = "Serial Port Enable";
|
|
btn_SerialCfgMass_CmdMeter2Close.Enabled = false;
|
|
btn_SerialCfgMass_CmdMeter2Inhibit.Enabled = false;
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfgMass_CmdMeter2Inhibit() failed", $"0x{ex.HResult.ToString("X", Culture)}", String.Empty);
|
|
MessageBox.Show("Unknown error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SerialCfgMass_CmdMeter3Inhibit_Click(object sender, EventArgs e)
|
|
{
|
|
Boolean Ok = false;
|
|
CultureInfo Culture = GetGlobalCulture();
|
|
|
|
try
|
|
{
|
|
#region Serial port inhibit
|
|
Ok = SerialPortInhibit(ref serialPortCmdMeter3, Constants.CmdMeter3);
|
|
if (!Ok)
|
|
return;
|
|
CommandInterface3.Init(Constants.Meter3, serialPortCmdMeter3, Culture);
|
|
#endregion
|
|
#region On tab 'serial port configuration (mass)'
|
|
btn_SerialCfgMass_CmdMeter3Open.Enabled = true;
|
|
btn_SerialCfgMass_CmdMeter3Open.Text = "Serial Port Enable";
|
|
btn_SerialCfgMass_CmdMeter3Close.Enabled = false;
|
|
btn_SerialCfgMass_CmdMeter3Inhibit.Enabled = false;
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfgMass_CmdMeter3Inhibit() failed", $"0x{ex.HResult.ToString("X", Culture)}", String.Empty);
|
|
MessageBox.Show("Unknown error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SerialCfgMass_CmdMeter2Close_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean Ok = false;
|
|
String MessageBoxText = String.Empty;
|
|
CultureInfo Culture = GetGlobalCulture();
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
#region Serial port close
|
|
Ok = SerialPortClose(ref serialPortCmdMeter2, Constants.CmdMeter2, out MessageBoxText);
|
|
if (!Ok)
|
|
{
|
|
MessageBox.Show(MessageBoxText, "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
return;
|
|
}
|
|
CommandInterface2.Init(Constants.Meter2, serialPortCmdMeter2, Culture);
|
|
#endregion
|
|
#region On tab 'serial port configuration (mass)'
|
|
btn_SerialCfgMass_CmdMeter2Open.Enabled = true;
|
|
btn_SerialCfgMass_CmdMeter2Open.Text = "Serial Port Open";
|
|
btn_SerialCfgMass_CmdMeter2Close.Enabled = false;
|
|
btn_SerialCfgMass_CmdMeter2Inhibit.Enabled = false;
|
|
|
|
l_SerialCfgMass_CmdMeter2ComSelect.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter2ComSelect.Enabled = true;
|
|
l_SerialCfgMass_CmdMeter2Baudrate.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter2Baudrate.Enabled = true;
|
|
l_SerialCfgMass_CmdMeter2Databits.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter2Databits.Enabled = true;
|
|
l_SerialCfgMass_CmdMeter2Stopbits.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter2Stopbits.Enabled = true;
|
|
l_SerialCfgMass_CmdMeter2Parity.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter2Parity.Enabled = true;
|
|
l_SerialCfgMass_CmdMeter2Handshake.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter2Handshake.Enabled = true;
|
|
if ((serialPortCmdMeter1.IsOpen == false) &&
|
|
(serialPortCmdMeter3.IsOpen == false) &&
|
|
(serialPortDataMeter1.IsOpen == false) &&
|
|
(serialPortDataMeter2.IsOpen == false) &&
|
|
(serialPortDataMeter3.IsOpen == false))
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = true; // Mass logging check box
|
|
#endregion
|
|
#region Message box
|
|
MessageBox.Show("Serial Port closed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfgMass_CmdMeter2Close_Click() failed", $"0x{ex.HResult.ToString("X", Culture)}", String.Empty);
|
|
MessageBox.Show("Unknown error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SerialCfgMass_CmdMeter3Close_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean Ok = false;
|
|
String MessageBoxText = String.Empty;
|
|
CultureInfo Culture = GetGlobalCulture();
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
#region Serial port close
|
|
Ok = SerialPortClose(ref serialPortCmdMeter3, Constants.Meter3, out MessageBoxText);
|
|
if (!Ok)
|
|
{
|
|
MessageBox.Show(MessageBoxText, "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
return;
|
|
}
|
|
CommandInterface3.Init(Constants.Meter3, serialPortCmdMeter3, Culture);
|
|
#endregion
|
|
#region On tab 'serial port configuration (mass)'
|
|
btn_SerialCfgMass_CmdMeter3Open.Enabled = true;
|
|
btn_SerialCfgMass_CmdMeter3Open.Text = "Serial Port Open";
|
|
btn_SerialCfgMass_CmdMeter3Close.Enabled = false;
|
|
btn_SerialCfgMass_CmdMeter3Inhibit.Enabled = false;
|
|
|
|
l_SerialCfgMass_CmdMeter3ComSelect.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter3ComSelect.Enabled = true;
|
|
l_SerialCfgMass_CmdMeter3Baudrate.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter3Baudrate.Enabled = true;
|
|
l_SerialCfgMass_CmdMeter3Databits.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter3Databits.Enabled = true;
|
|
l_SerialCfgMass_CmdMeter3Stopbits.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter3Stopbits.Enabled = true;
|
|
l_SerialCfgMass_CmdMeter3Parity.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter3Parity.Enabled = true;
|
|
l_SerialCfgMass_CmdMeter3Handshake.Enabled = true;
|
|
lB_SerialCfgMass_CmdMeter3Handshake.Enabled = true;
|
|
|
|
if ((serialPortCmdMeter1.IsOpen == false) &&
|
|
(serialPortCmdMeter2.IsOpen == false) &&
|
|
(serialPortDataMeter1.IsOpen == false) &&
|
|
(serialPortDataMeter2.IsOpen == false) &&
|
|
(serialPortDataMeter3.IsOpen == false))
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = true; // Mass logging check box
|
|
#endregion
|
|
#region Message box
|
|
MessageBox.Show("Serial Port closed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfgMass_CmdMeter3Close_Click() failed", $"0x{ex.HResult.ToString("X", Culture)}", String.Empty);
|
|
MessageBox.Show("Unknown error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
public static Type GetType(String input)
|
|
{
|
|
if (!String.IsNullOrEmpty(input))
|
|
{
|
|
if (String.Equals(input, "RfidComPort"))
|
|
return typeof(RfidSerialPort);
|
|
if (String.Equals(input, "SerialComPort"))
|
|
return typeof(UartSerialPort);
|
|
if (String.Equals(input, "IrdaComPort"))
|
|
return typeof(IrdaSerialPort);
|
|
|
|
return typeof(RfidSerialPort);
|
|
}
|
|
else
|
|
return typeof(RfidSerialPort);
|
|
}
|
|
|
|
private void btn_SerialCfg_CmdOpen_Click(object sender, EventArgs e)
|
|
{
|
|
Boolean LoginSuccessful = false;
|
|
const UInt16 LengthOfPassword = 12;
|
|
|
|
|
|
try
|
|
{
|
|
gBSerialCfgCommand.Enabled = false;
|
|
gB_SerialCfg_Data.Enabled = false;
|
|
FormControl.DisableTabExceptSerialConfig(true);
|
|
pB_Bubbles.Visible = true;
|
|
btn_SerialCfg_CmdOpen.Enabled = false;
|
|
btn_SerialCfg_CmdClose.Enabled = false;
|
|
|
|
if (((tBLogOnMeter1.TextLength < LengthOfPassword) && (tBLogOnMeter1.TextLength > 0)) && (!Misc.OnlyHexInString(tBLogOnMeter1.Text)))
|
|
{
|
|
pB_Bubbles.Visible = false;
|
|
MessageBox.Show("PASSWORD not valid", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
gBSerialCfgCommand.Enabled = true;
|
|
gB_SerialCfg_Data.Enabled = true;
|
|
btn_SerialCfg_CmdOpen.Enabled = true;
|
|
btn_SerialCfg_CmdClose.Enabled = false;
|
|
FormControl.DisableTabExceptSerialConfig(false);
|
|
return;
|
|
}
|
|
if (String.IsNullOrEmpty(lB_SerialCfg_CmdChannel.Text) || (String.IsNullOrEmpty(lB_SerialCfg_TransferMode.Text)))
|
|
{
|
|
pB_Bubbles.Visible = false;
|
|
MessageBox.Show("COMPORT settings not valid", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
gBSerialCfgCommand.Enabled = true;
|
|
gB_SerialCfg_Data.Enabled = true;
|
|
FormControl.DisableTabExceptSerialConfig(false);
|
|
btn_SerialCfg_CmdOpen.Enabled = true;
|
|
btn_SerialCfg_CmdClose.Enabled = false;
|
|
return;
|
|
}
|
|
|
|
|
|
btn_SerialCfg_CmdOpen.Enabled = false;
|
|
String temp = lB_SerialCfg_TransferMode.Text;
|
|
var baudRate = 9600;
|
|
if (GetType(temp) == typeof(IrdaSerialPort))
|
|
{
|
|
baudRate = 115200;
|
|
}
|
|
|
|
|
|
PortConfig requestPort1 = new PortConfig()
|
|
{
|
|
PortName = lB_SerialCfg_CmdChannel.Text,
|
|
Type = GetType(temp).FullName,
|
|
};
|
|
DisplayOnTab = SelectedTab.None;
|
|
|
|
#region Command channel
|
|
GlobalMeterBatch = new MeterBatch();
|
|
currentMeter = new GenesisMeter();
|
|
currentMeter.SetupGenesisMeter(1, requestPort1, null);
|
|
GlobalMeterBatch.AddMeter(currentMeter);
|
|
currentMeter.OnRequestRecordReceived += CurrentMeter_OnRequestdataRecived;
|
|
#endregion
|
|
#region Definitions and initializations
|
|
String Password = tBLogOnMeter1.Text;
|
|
String Timestamp = DateTime.Now.ToString(Formats.RawDataDateTimeLogString, this.globalCulture);
|
|
#endregion
|
|
|
|
Task<Boolean> MyTask = Task.Run(() =>
|
|
{
|
|
|
|
foreach (var generalMeter in GlobalMeterBatch.ListOfMeters)
|
|
{
|
|
if (String.IsNullOrEmpty(Password))
|
|
{
|
|
if (generalMeter is GenesisMeter)
|
|
{
|
|
generalMeter.Login();
|
|
if (((GenesisMeter)generalMeter).IsLoggedOn)
|
|
LoginSuccessful = true;
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (generalMeter is GenesisMeter)
|
|
{
|
|
generalMeter.Login(Password);
|
|
if (((GenesisMeter)generalMeter).IsLoggedOn)
|
|
LoginSuccessful = true;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
return LoginSuccessful;
|
|
});
|
|
while (MyTask.Status != TaskStatus.RanToCompletion)
|
|
{
|
|
Misc.WaitNSeconds(1);
|
|
}
|
|
if (LoginSuccessful)
|
|
{
|
|
pB_Bubbles.Visible = false;
|
|
MessageBox.Show("LOGIN procedure successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
FormControl.DisableTabExceptSerialConfig(false);
|
|
gB_Form1Logging.Enabled = true;
|
|
btn_SerialCfg_CmdOpen.Enabled = false;
|
|
btn_SerialCfg_CmdClose.Enabled = true;
|
|
gBSerialCfgCommand.Enabled = true;
|
|
gB_SerialCfg_Data.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
pB_Bubbles.Visible = false;
|
|
MessageBox.Show("LOGIN procedure failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.DisableTabExceptSerialConfig(false);
|
|
btn_SerialCfg_CmdOpen.Enabled = true;
|
|
btn_SerialCfg_CmdClose.Enabled = false;
|
|
gB_SerialCfg_Data.Enabled = true;
|
|
gBSerialCfgCommand.Enabled = true;
|
|
|
|
#region Close sequence
|
|
GlobalMeterBatch.RemoveAllMeters();
|
|
|
|
if (serialPortDataMeter1.IsOpen)
|
|
{
|
|
//serialPortDataMeter1.DataReceived -= CurrentMeter_OnRequestdataRecived;
|
|
serialPortDataMeter1.DataReceived -= serialPortDataMeter1DataReceived;
|
|
Misc.WaitNSeconds(1);
|
|
while (serialPortDataMeter1.IsOpen)
|
|
serialPortDataMeter1.Close();
|
|
}
|
|
gB_Form1Logging.Enabled = false;
|
|
#endregion
|
|
}
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfg_CmdOpen_Click() failed", $"0x{ex.HResult.ToString("X", globalCulture)}", String.Empty);
|
|
MessageBox.Show("Serial port could not be opened", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
pB_Bubbles.Visible = false;
|
|
FormControl.DisableTabExceptSerialConfig(false);
|
|
gBSerialCfgCommand.Enabled = true;
|
|
btn_SerialCfg_CmdOpen.Enabled = true;
|
|
btn_SerialCfg_CmdClose.Enabled = false;
|
|
}
|
|
}
|
|
|
|
private void CurrentMeter_OnRequestdataRecived(object sender, RequestResponseDataEventArgs e)
|
|
{
|
|
CultureInfo Culture = GetGlobalCulture();
|
|
Task.Run(() =>
|
|
{
|
|
var tmpCmdinterface = new CmdInterface();
|
|
tmpCmdinterface.Init(0, null, Culture);
|
|
|
|
var tmpList = new List<Byte>();
|
|
|
|
foreach (var item in e.RequestResponseData)
|
|
{
|
|
tmpList.Add(item);
|
|
}
|
|
|
|
//tmpCmdinterface.ReadDataResponse(tmpList);
|
|
|
|
Invoke((Action<List<Byte>>)GetReplyCmdMeterFromCommon1, e.RequestResponseData);
|
|
});
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
private void btn_SerialCfg_CmdClose_Click(object sender, EventArgs e)
|
|
{
|
|
btn_SerialCfg_CmdOpen.Enabled = false;
|
|
btn_SerialCfg_CmdClose.Enabled = false;
|
|
gBSerialCfgCommand.Enabled = false;
|
|
gB_SerialCfg_Data.Enabled = false;
|
|
try
|
|
{
|
|
GlobalMeterBatch.RemoveAllMeters();
|
|
|
|
//if (serialPortDataMeter1.IsOpen)
|
|
//{
|
|
// //serialPortDataMeter1.DataReceived -= CurrentMeter_OnRequestdataRecived;
|
|
// serialPortDataMeter1.DataReceived -= serialPortDataMeter1DataReceived;
|
|
// Misc.WaitNSeconds(1);
|
|
// while(serialPortDataMeter1.IsOpen)
|
|
// serialPortDataMeter1.Close();
|
|
//}
|
|
gB_Form1Logging.Enabled = false;
|
|
MessageBox.Show("Serial Port closed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
btn_SerialCfg_CmdOpen.Enabled = true;
|
|
btn_SerialCfg_CmdClose.Enabled = false;
|
|
gBSerialCfgCommand.Enabled = true;
|
|
gB_SerialCfg_Data.Enabled = true;
|
|
gBSerialCfgCommand.Enabled = true;
|
|
gB_SerialCfg_Data.Enabled = true;
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfg_CmdClose_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Serial Port could not be closed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
btn_SerialCfg_CmdOpen.Enabled = false;
|
|
btn_SerialCfg_CmdClose.Enabled = false;
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
|
|
|
|
private void btn_SerialCfgMass_DataMeter1Open_Click(object sender, EventArgs e)
|
|
{
|
|
Boolean Ok = false;
|
|
|
|
try
|
|
{
|
|
#region Open serial port
|
|
WaitForBackgroundWorkers();
|
|
Ok = SerialPort_DataMeter1Open(MassLogging);
|
|
if (!Ok)
|
|
return;
|
|
#endregion
|
|
#region On tab 'serial port configuration'
|
|
|
|
l_SerialCfg_DataComSelect.Enabled = false;
|
|
lB_SerialCfg_DataComSelect.Enabled = false;
|
|
#endregion
|
|
#region On tab 'serial port configuration (mass)'
|
|
WaitForBackgroundWorkers();
|
|
btn_SerialCfgMass_DataMeter1Open.Enabled = false;
|
|
btn_SerialCfgMass_DataMeter1Close.Enabled = true;
|
|
btn_SerialCfgMass_DataMeter1Inhibit.Enabled = true;
|
|
|
|
l_SerialCfgMass_DataMeter1ComSelect.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter1ComSelect.Enabled = false;
|
|
l_SerialCfgMass_DataMeter1Baudrate.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter1Baudrate.Enabled = false;
|
|
l_SerialCfgMass_DataMeter1Databits.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter1Databits.Enabled = false;
|
|
l_SerialCfgMass_DataMeter1Stopbits.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter1Stopbits.Enabled = false;
|
|
l_SerialCfgMass_DataMeter1Parity.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter1Parity.Enabled = false;
|
|
l_SerialCfgMass_DataMeter1Handshake.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter1Handshake.Enabled = false;
|
|
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = false; // Mass logging check box
|
|
#endregion
|
|
#region Synchronize selected items
|
|
lB_SerialCfg_DataComSelect.SelectedIndex = lB_SerialCfgMass_DataMeter1ComSelect.SelectedIndex;
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfgMass_DataMeter1Open_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Serial port could not be opened", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
|
|
private void btn_SerialCfgMass_DataMeter1Inhibit_Click(object sender, EventArgs e)
|
|
{
|
|
Boolean Ok = false;
|
|
|
|
try
|
|
{
|
|
#region Serial port inhibit
|
|
Ok = SerialPortInhibit(ref serialPortDataMeter1, Constants.DataMeter1);
|
|
if (!Ok)
|
|
return;
|
|
#endregion
|
|
#region On tab 'serial port configuration (mass)'
|
|
btn_SerialCfgMass_DataMeter1Open.Enabled = true;
|
|
btn_SerialCfgMass_DataMeter1Open.Text = "Serial Port Enable";
|
|
btn_SerialCfgMass_DataMeter1Close.Enabled = false;
|
|
btn_SerialCfgMass_DataMeter1Inhibit.Enabled = false;
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfgMass_DataMeter1Inhibit_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Unknown error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SerialCfgMass_DataMeter1Close_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean Ok = false;
|
|
String MessageBoxText = String.Empty;
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
#region Serial port close
|
|
Ok = SerialPortClose(ref serialPortDataMeter1, Constants.DataMeter1, out MessageBoxText);
|
|
if (!Ok)
|
|
{
|
|
MessageBox.Show(MessageBoxText, "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
return;
|
|
}
|
|
#endregion
|
|
#region On tab 'serial port configuration'
|
|
l_SerialCfg_DataComSelect.Enabled = true;
|
|
lB_SerialCfg_DataComSelect.Enabled = true;
|
|
#endregion
|
|
#region On tab 'serial port configuration (mass)'
|
|
btn_SerialCfgMass_DataMeter1Open.Enabled = true;
|
|
btn_SerialCfgMass_DataMeter1Open.Text = "Serial Port Open";
|
|
btn_SerialCfgMass_DataMeter1Close.Enabled = false;
|
|
btn_SerialCfgMass_DataMeter1Inhibit.Enabled = false;
|
|
|
|
l_SerialCfgMass_DataMeter1ComSelect.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter1ComSelect.Enabled = true;
|
|
l_SerialCfgMass_DataMeter1Baudrate.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter1Baudrate.Enabled = true;
|
|
l_SerialCfgMass_DataMeter1Databits.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter1Databits.Enabled = true;
|
|
l_SerialCfgMass_DataMeter1Stopbits.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter1Stopbits.Enabled = true;
|
|
l_SerialCfgMass_DataMeter1Parity.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter1Parity.Enabled = true;
|
|
l_SerialCfgMass_DataMeter1Handshake.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter1Handshake.Enabled = true;
|
|
|
|
if ((serialPortCmdMeter1.IsOpen == false) &&
|
|
(serialPortCmdMeter2.IsOpen == false) &&
|
|
(serialPortCmdMeter3.IsOpen == false) &&
|
|
(serialPortDataMeter2.IsOpen == false) &&
|
|
(serialPortDataMeter3.IsOpen == false))
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = true; // Mass logging check box
|
|
#endregion
|
|
#region Message box
|
|
MessageBox.Show("Serial Port closed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialConfigMassDataChannel1Close_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Unknown error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SerialCfgMass_DataMeter2Open_Click(object sender, EventArgs e)
|
|
{
|
|
Boolean Ok = false;
|
|
|
|
try
|
|
{
|
|
#region Open serial port
|
|
WaitForBackgroundWorkers();
|
|
Ok = SerialPort_DataMeter2Open(MassLogging);
|
|
if (!Ok)
|
|
return;
|
|
#endregion
|
|
#region Serial config elements
|
|
WaitForBackgroundWorkers();
|
|
btn_SerialCfgMass_DataMeter2Open.Enabled = false;
|
|
btn_SerialCfgMass_DataMeter2Close.Enabled = true;
|
|
btn_SerialCfgMass_DataMeter2Inhibit.Enabled = true;
|
|
|
|
l_SerialCfgMass_DataMeter2ComSelect.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter2ComSelect.Enabled = false;
|
|
l_SerialCfgMass_DataMeter2Baudrate.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter2Baudrate.Enabled = false;
|
|
l_SerialCfgMass_DataMeter2Databits.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter2Databits.Enabled = false;
|
|
l_SerialCfgMass_DataMeter2Stopbits.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter2Stopbits.Enabled = false;
|
|
l_SerialCfgMass_DataMeter2Parity.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter2Parity.Enabled = false;
|
|
l_SerialCfgMass_DataMeter2Handshake.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter2Handshake.Enabled = false;
|
|
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = false; // Mass logging check box
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfgMass_DataMeter2Open_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Serial port could not be opened", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
|
|
private void btn_SerialCfgMass_DataMeter2Inhibit_Click(object sender, EventArgs e)
|
|
{
|
|
Boolean Ok = false;
|
|
try
|
|
{
|
|
#region Serial port inhibit
|
|
Ok = SerialPortInhibit(ref serialPortDataMeter2, Constants.DataMeter2);
|
|
if (!Ok)
|
|
return;
|
|
#endregion
|
|
#region Serial port related control elements
|
|
btn_SerialCfgMass_DataMeter2Open.Enabled = true;
|
|
btn_SerialCfgMass_DataMeter2Open.Text = "Serial Port Enable";
|
|
btn_SerialCfgMass_DataMeter2Close.Enabled = false;
|
|
btn_SerialCfgMass_DataMeter2Inhibit.Enabled = false;
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfgMass_DataMeter2Inhibit_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Unknown error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SerialCfgMass_DataMeter2Close_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean Ok = false;
|
|
String DebugMessage = String.Empty;
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
#region Serial port close
|
|
Ok = SerialPortClose(ref serialPortDataMeter2, Constants.DataMeter2, out DebugMessage);
|
|
if (!Ok)
|
|
{
|
|
MessageBox.Show(DebugMessage, "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
return;
|
|
}
|
|
#endregion
|
|
#region On tab 'serial port configuration (mass)'
|
|
btn_SerialCfgMass_DataMeter2Open.Enabled = true;
|
|
btn_SerialCfgMass_DataMeter2Open.Text = "Serial Port Open";
|
|
btn_SerialCfgMass_DataMeter2Close.Enabled = false;
|
|
btn_SerialCfgMass_DataMeter2Inhibit.Enabled = false;
|
|
|
|
l_SerialCfgMass_DataMeter2ComSelect.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter2ComSelect.Enabled = true;
|
|
l_SerialCfgMass_DataMeter2Baudrate.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter2Baudrate.Enabled = true;
|
|
l_SerialCfgMass_DataMeter2Databits.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter2Databits.Enabled = true;
|
|
l_SerialCfgMass_DataMeter2Stopbits.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter2Stopbits.Enabled = true;
|
|
l_SerialCfgMass_DataMeter2Parity.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter2Parity.Enabled = true;
|
|
l_SerialCfgMass_DataMeter2Handshake.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter2Handshake.Enabled = true;
|
|
|
|
if ((serialPortCmdMeter1.IsOpen == false) &&
|
|
(serialPortCmdMeter2.IsOpen == false) &&
|
|
(serialPortCmdMeter3.IsOpen == false) &&
|
|
(serialPortDataMeter1.IsOpen == false) &&
|
|
(serialPortDataMeter3.IsOpen == false))
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = true; // Mass logging check box
|
|
#endregion
|
|
#region Message box
|
|
MessageBox.Show("Serial Port closed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfgMass_DataMeter2Close_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Unknown error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SerialCfgMass_DataMeter3Open_Click(object sender, EventArgs e)
|
|
{
|
|
Boolean Ok = false;
|
|
|
|
try
|
|
{
|
|
#region Open serial port
|
|
WaitForBackgroundWorkers();
|
|
Ok = SerialPort_DataMeter3Open(MassLogging);
|
|
if (!Ok)
|
|
return;
|
|
#endregion
|
|
#region Serial config elements
|
|
WaitForBackgroundWorkers();
|
|
btn_SerialCfgMass_DataMeter3Open.Enabled = false;
|
|
btn_SerialCfgMass_DataMeter3Close.Enabled = true;
|
|
btn_SerialCfgMass_DataMeter3Inhibit.Enabled = true;
|
|
|
|
l_SerialCfgMass_DataMeter3ComSelect.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter3ComSelect.Enabled = false;
|
|
l_SerialCfgMass_DataMeter3Baudrate.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter3Baudrate.Enabled = false;
|
|
l_SerialCfgMass_DataMeter3Databits.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter3Databits.Enabled = false;
|
|
l_SerialCfgMass_DataMeter3Stopbits.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter3Stopbits.Enabled = false;
|
|
l_SerialCfgMass_DataMeter3Parity.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter3Parity.Enabled = false;
|
|
l_SerialCfgMass_DataMeter3Handshake.Enabled = false;
|
|
lB_SerialCfgMass_DataMeter3Handshake.Enabled = false;
|
|
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = false; // Mass logging check box
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), $"btn_SerialConfigMassDataChannel3Open_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}"
|
|
, String.Empty);
|
|
MessageBox.Show("Serial port could not be opened", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
|
|
private void btn_SerialCfgMass_DataMeter3Inhibit_Click(object sender, EventArgs e)
|
|
{
|
|
Boolean Ok = false;
|
|
|
|
try
|
|
{
|
|
#region Serial port inhibit
|
|
Ok = SerialPortInhibit(ref serialPortDataMeter3, Constants.DataMeter3);
|
|
if (!Ok)
|
|
return;
|
|
#endregion
|
|
#region Serial port related control elements
|
|
btn_SerialCfgMass_DataMeter3Open.Enabled = true;
|
|
btn_SerialCfgMass_DataMeter3Open.Text = "Serial Port Enable";
|
|
btn_SerialCfgMass_DataMeter3Close.Enabled = false;
|
|
btn_SerialCfgMass_DataMeter3Inhibit.Enabled = false;
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialCfgMass_DataMeter3Inhibit_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Unknown error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SerialCfgMass_DataMeter3Close_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean Ok = false;
|
|
String MessageBoxText = String.Empty;
|
|
#endregion
|
|
|
|
try
|
|
{
|
|
#region Serial port close
|
|
Ok = SerialPortClose(ref serialPortDataMeter3, Constants.DataMeter3, out MessageBoxText);
|
|
if (!Ok)
|
|
{
|
|
MessageBox.Show(MessageBoxText, "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
return;
|
|
}
|
|
#endregion
|
|
#region Serial port related control elements
|
|
btn_SerialCfgMass_DataMeter3Open.Enabled = true;
|
|
btn_SerialCfgMass_DataMeter3Open.Text = "Serial Port Open";
|
|
btn_SerialCfgMass_DataMeter3Close.Enabled = false;
|
|
btn_SerialCfgMass_DataMeter3Inhibit.Enabled = false;
|
|
|
|
l_SerialCfgMass_DataMeter3ComSelect.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter3ComSelect.Enabled = true;
|
|
l_SerialCfgMass_DataMeter3Baudrate.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter3Baudrate.Enabled = true;
|
|
l_SerialCfgMass_DataMeter3Databits.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter3Databits.Enabled = true;
|
|
l_SerialCfgMass_DataMeter3Stopbits.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter3Stopbits.Enabled = true;
|
|
l_SerialCfgMass_DataMeter3Parity.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter3Parity.Enabled = true;
|
|
l_SerialCfgMass_DataMeter3Handshake.Enabled = true;
|
|
lB_SerialCfgMass_DataMeter3Handshake.Enabled = true;
|
|
|
|
if ((serialPortCmdMeter1.IsOpen == false) &&
|
|
(serialPortCmdMeter2.IsOpen == false) &&
|
|
(serialPortCmdMeter3.IsOpen == false) &&
|
|
(serialPortDataMeter1.IsOpen == false) &&
|
|
(serialPortDataMeter2.IsOpen == false))
|
|
cB_SerialConfigMassMassLoggingEn.Enabled = true; // Mass logging check box
|
|
#endregion
|
|
#region Message box
|
|
MessageBox.Show("Serial Port closed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
#endregion
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SerialConfigMassDataChannel3Close_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Unknown error", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
#endregion
|
|
#region List boxes serial config
|
|
|
|
private void lB_SerialCfg_DataComSelect_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
if (!MassLogging)
|
|
lB_SerialCfgMass_DataMeter1ComSelect.SelectedIndex = lB_SerialCfg_DataComSelect.SelectedIndex;
|
|
}
|
|
|
|
private void lB_SerialCfgMass_CmdMeter1ComSelect_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
if (MassLogging)
|
|
lB_SerialCfg_CmdChannel.SelectedIndex = lB_SerialCfgMass_CmdMeter1ComSelect.SelectedIndex;
|
|
}
|
|
|
|
private void lB_SerialCfgMass_CmdMeter1Baudrate_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
//if (MassLogging)
|
|
// lB_SerialCfg_CmdBaudrate.SelectedIndex = lB_SerialCfgMass_CmdMeter1Baudrate.SelectedIndex;
|
|
}
|
|
|
|
private void lB_SerialCfgMass_CmdMeter1Databits_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
// if (MassLogging)
|
|
// lB_SerialCfg_CmdDatabits.SelectedIndex = lB_SerialCfgMass_CmdMeter1Databits.SelectedIndex;
|
|
|
|
}
|
|
|
|
private void lB_SerialCfgMass_CmdMeter1Stopbits_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
//if (MassLogging)
|
|
// lB_SerialCfg_CmdStopbits.SelectedIndex = lB_SerialCfgMass_CmdMeter1Stopbits.SelectedIndex;
|
|
}
|
|
|
|
private void lB_SerialCfgMass_CmdMeter1Parity_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
//if (MassLogging)
|
|
// lB_SerialCfg_CmdParity.SelectedIndex = lB_SerialCfgMass_CmdMeter1Parity.SelectedIndex;
|
|
}
|
|
|
|
private void lB_SerialCfgMass_CmdMeter1Handshake_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
//if (MassLogging)
|
|
// lB_SerialCfg_CmdHandshake.SelectedIndex = lB_SerialCfgMass_CmdMeter1Handshake.SelectedIndex;
|
|
}
|
|
|
|
private void lB_SerialCfgMass_DataMeter1ComSelect_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
if (MassLogging)
|
|
lB_SerialCfg_DataComSelect.SelectedIndex = lB_SerialCfgMass_DataMeter1ComSelect.SelectedIndex;
|
|
}
|
|
|
|
private void lB_SerialCfgMass_DataMeter1Baudrate_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
//if (MassLogging)
|
|
// lB_SerialCfg_DataBaudrate.SelectedIndex = lB_SerialCfgMass_DataMeter1Baudrate.SelectedIndex;
|
|
}
|
|
|
|
private void lB_SerialCfgMass_DataMeter1Databits_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
// if (MassLogging)
|
|
// lB_SerialCfg_DataDatabits.SelectedIndex = lB_SerialCfgMass_DataMeter1Databits.SelectedIndex;
|
|
}
|
|
|
|
private void lB_SerialCfgMass_DataMeter1Stopbits_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
//if (MassLogging)
|
|
// lB_SerialCfg_DataStopbits.SelectedIndex = lB_SerialCfgMass_DataMeter1Stopbits.SelectedIndex;
|
|
}
|
|
|
|
private void lB_SerialCfgMass_DataMeter1Parity_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
//if (MassLogging)
|
|
// lB_SerialCfg_DataParity.SelectedIndex = lB_SerialCfgMass_DataMeter1Parity.SelectedIndex;
|
|
}
|
|
|
|
private void lB_SerialCfgMass_DataMeter1Handshake_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
//if (MassLogging)
|
|
// lB_SerialCfg_DataHandshake.SelectedIndex = lB_SerialCfgMass_DataMeter1Handshake.SelectedIndex;
|
|
}
|
|
#endregion
|
|
#region GP30 control elements ("COMMAND CHANNEL")
|
|
#region Set GP30 register values from Form1
|
|
#region GP30 numeric up down
|
|
private void nUD_GraphSetFirstLevelUpPath0_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
// l_SideSetPercentPath0.Text = $"{((Double)nUD_SideSetPercentPath0.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_GraphSetFirstLevelUpPath1_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
// l_SideSetPercentPath1.Text = $"{((Double)nUD_SideSetPercentPath1.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_GraphSetFirstLevelUpPath2_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
// l_SideSetPercentPath2.Text = $"{((Double)nUD_SideSetPercentPath2.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{ Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
#endregion
|
|
#endregion
|
|
#region from GP30 tabs
|
|
#region GP30 buttons
|
|
private void btn_GP30calFactor1Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.CalFactor1);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_GP30calFactor2Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.CalFactor2);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_GP30zeroOffset1Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.ZeroOffset1);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_GP30zeroOffset2Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.ZeroOffset2);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_GP30zeroOffset3Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.ZeroOffset3);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30GetNumberOfTXBurstsMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.NumFirePulses);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30GetNumberOfTXBurstsMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.NumFirePulses);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30GetStartHitMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.StartHit);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30GetStartHitMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.StartHit);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30GetStartHitMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.StartHit);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30GetAmplitudeMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.AmplitudePeakDetectEnd);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30GetAmplitudeMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.AmplitudePeakDetectEnd);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30GetAmplitudeMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.AmplitudePeakDetectEnd);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30GetSamplerateMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.SampleRate);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30GetSamplerateMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.SampleRate);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30GetSamplerateMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.SampleRate);
|
|
jobToDo.Start();
|
|
}
|
|
|
|
private Task<byte[]> ReadRegister(GenesisMeter meter, string reg)
|
|
{
|
|
|
|
int slot = 1;// meter.Slot;
|
|
|
|
var regDef = meter.GetRegisterDefinitionByName(reg);
|
|
|
|
switch (slot)
|
|
{
|
|
case 1:
|
|
CommandInterface1.Gp30LastRegister = reg;
|
|
CommandInterface1.Gp30LastCommand = GP30Commands.ReadData;
|
|
break;
|
|
case 2:
|
|
CommandInterface2.Gp30LastRegister = reg;
|
|
CommandInterface2.Gp30LastCommand = GP30Commands.ReadData;
|
|
break;
|
|
case 3:
|
|
CommandInterface3.Gp30LastRegister = reg;
|
|
CommandInterface3.Gp30LastCommand = GP30Commands.ReadData;
|
|
break;
|
|
default: break;
|
|
}
|
|
|
|
return new Task<byte[]>(() =>
|
|
{
|
|
switch (slot)
|
|
{
|
|
case 1:
|
|
CommandInterface1.Gp30LastRegister = reg;
|
|
CommandInterface1.Gp30LastCommand = GP30Commands.ReadData;
|
|
break;
|
|
case 2:
|
|
CommandInterface2.Gp30LastRegister = reg;
|
|
CommandInterface2.Gp30LastCommand = GP30Commands.ReadData;
|
|
break;
|
|
case 3:
|
|
CommandInterface3.Gp30LastRegister = reg;
|
|
CommandInterface3.Gp30LastCommand = GP30Commands.ReadData;
|
|
break;
|
|
}
|
|
|
|
if (regDef.DataType == typeof(string))
|
|
{
|
|
return ((GenesisMeter)GlobalMeterBatch.ListOfMeters.First()).MultipleReadRegister(reg);
|
|
}
|
|
else if (regDef.DataType == typeof(UInt96))
|
|
{
|
|
return ((GenesisMeter)GlobalMeterBatch.ListOfMeters.First()).MultipleReadRegister(reg);
|
|
}
|
|
else
|
|
{
|
|
return ((GenesisMeter)GlobalMeterBatch.ListOfMeters.First()).ReadRegister(reg);
|
|
}
|
|
|
|
|
|
});
|
|
}
|
|
|
|
private Task<Boolean> WriteRegisterSave<T>(GenesisMeter meter, string reg, T value)
|
|
{
|
|
int slot = 1; // meter.Slot;
|
|
var regDef = meter.GetRegisterDefinitionByName(reg);
|
|
|
|
switch (slot)
|
|
{
|
|
case 1:
|
|
CommandInterface1.Gp30LastRegister = reg;
|
|
break;
|
|
case 2:
|
|
CommandInterface2.Gp30LastRegister = reg;
|
|
break;
|
|
case 3:
|
|
CommandInterface3.Gp30LastRegister = reg;
|
|
break;
|
|
default: break;
|
|
|
|
|
|
}
|
|
return new Task<Boolean>(() =>
|
|
{
|
|
return meter.WriteRegisterSafe(reg, value);
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private Task<Boolean> WriteRegister<T>(GenesisMeter meter, string reg, Byte[] value)
|
|
{
|
|
int slot = meter.Slot;
|
|
var regDef = meter.GetRegisterDefinitionByName(reg);
|
|
switch (slot)
|
|
{
|
|
case 1:
|
|
CommandInterface1.Gp30LastRegister = reg;
|
|
CommandInterface1.Gp30LastCommand = GP30Commands.WriteData;
|
|
break;
|
|
case 2:
|
|
CommandInterface2.Gp30LastRegister = reg;
|
|
CommandInterface2.Gp30LastCommand = GP30Commands.WriteData;
|
|
break;
|
|
case 3:
|
|
CommandInterface3.Gp30LastRegister = reg;
|
|
CommandInterface3.Gp30LastCommand = GP30Commands.WriteData;
|
|
break;
|
|
default: break;
|
|
|
|
|
|
|
|
}
|
|
|
|
return new Task<Boolean>(() =>
|
|
{
|
|
return meter.WriteRegister(reg, value, true);
|
|
});
|
|
}
|
|
|
|
private void btn_GetFirstLevelUpPath0Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.FirstHitLvlUp1);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
});
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_GetFirstLevelUpPath0Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.FirstHitLvlUp1);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_GetFirstLevelUpPath0Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.FirstHitLvlUp1);
|
|
jobToDo.Start();
|
|
|
|
}
|
|
private void btn_GetFirstLevelUpPath1Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.FirstHitLvlUp2);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_GetFirstLevelUpPath1Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.FirstHitLvlUp2);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_GetFirstLevelUpPath1Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.FirstHitLvlUp2);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_GetFirstLevelUpPath2Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.FirstHitLvlUp3);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_GetFirstLevelUpPath2Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.FirstHitLvlUp3);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_GetFirstLevelUpPath2Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.FirstHitLvlUp3);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_GetFirstLevelDownPath0Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.FirstHitLvlDown1);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_GetFirstLevelDownPath0Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.FirstHitLvlDown1);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_GetFirstLevelDownPath0Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.FirstHitLvlDown1);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_GetFirstLevelDownPath1Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.FirstHitLvlDown2);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_GetFirstLevelDownPath1Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.FirstHitLvlDown2);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_GetFirstLevelDownPath1Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.FirstHitLvlDown2);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_GetFirstLevelDownPath2Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.FirstHitLvlDown3);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_GetFirstLevelDownPath2Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.FirstHitLvlDown3);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_GetFirstLevelDownPath2Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.FirstHitLvlDown3);
|
|
jobToDo.Start();
|
|
}
|
|
|
|
private void btn_CommandChannelVoltageMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Powermon.BatteryVoltage);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_CommandChannelVoltageMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Powermon.BatteryVoltage);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_CommandChannelVoltageMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Powermon.BatteryVoltage);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30GetSerialNoMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
String PcbId = currentMeter.PcbId;
|
|
String Timestamp = DateTime.Now.ToString(Formats.RawDataDateTimeLogString, GetGlobalCulture());
|
|
|
|
if (!String.IsNullOrEmpty(PcbId))
|
|
{
|
|
GENESIS_DISPLAY_TOOL.Display.CmdDecoded($"{Timestamp}\tCOMMAND CHANNEL\t Received response on read 'PcbID'-register = {PcbId} at METER1\n", Constants.Meter1);
|
|
}
|
|
else
|
|
{
|
|
GENESIS_DISPLAY_TOOL.Display.CmdDecoded($"{Timestamp}\tCOMMAND CHANNEL\t PcbID could not be obtained at METER1\n", Constants.Meter1);
|
|
}
|
|
|
|
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30GetSerialNoMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Configexchange.PCBSerialNumber);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30GetSerialNoMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Configexchange.PCBSerialNumber);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30getLedModeMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.LedMode);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30getLedModeMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.LedMode);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30getLedModeMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.LedMode);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30getForwardArrowMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.ForwardArrow);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30getForwardArrowMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.ForwardArrow);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30getForwardArrowMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.ForwardArrow);
|
|
jobToDo.Start();
|
|
}
|
|
private GenesisMeter CheckMeterConnected(int slot)
|
|
{
|
|
GenesisMeter ret = (GenesisMeter)GlobalMeterBatch.GetMeter(slot);
|
|
if (ret == null)
|
|
{
|
|
//todo better handling
|
|
throw new Exception("METER not connected");
|
|
}
|
|
return ret;
|
|
}
|
|
private void btn_SetFirstLevelUpPath0Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelUpPath0Meter1.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.FirstHitLvlUp1, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_SetFirstLevelUpPath0Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelUpPath0Meter2.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.FirstHitLvlUp1, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_SetFirstLevelUpPath0Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelUpPath0Meter3.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.FirstHitLvlUp1, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_SetFirstLevelUpPath1Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelUpPath1Meter1.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.FirstHitLvlUp2, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_SetFirstLevelUpPath1Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelUpPath1Meter2.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
|
|
try
|
|
{
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.FirstHitLvlUp2, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
|
|
}
|
|
private void btn_SetFirstLevelUpPath1Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelUpPath1Meter3.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.FirstHitLvlUp2, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_SetFirstLevelUpPath2Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelUpPath2Meter1.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.FirstHitLvlUp3, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_SetFirstLevelUpPath2Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelUpPath2Meter2.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.FirstHitLvlUp3, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_SetFirstLevelUpPath2Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelUpPath2Meter3.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.FirstHitLvlUp3, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_SetFirstLevelDownPath0Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelDownPath0Meter1.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.FirstHitLvlDown1, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_SetFirstLevelDownPath0Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelDownPath0Meter2.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.FirstHitLvlDown2, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_SetFirstLevelDownPath0Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelDownPath0Meter3.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.FirstHitLvlDown3, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_SetFirstLevelDownPath1Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelDownPath1Meter1.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.FirstHitLvlDown2, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_SetFirstLevelDownPath1Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelDownPath1Meter2.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.FirstHitLvlDown2, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_SetFirstLevelDownPath1Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelDownPath1Meter3.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.FirstHitLvlDown2, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_SetFirstLevelDownPath2Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelDownPath2Meter1.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.FirstHitLvlDown3, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_SetFirstLevelDownPath2Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelDownPath2Meter2.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.FirstHitLvlDown3, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_SetFirstLevelDownPath2Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SetFirstLevelDownPath2Meter3.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.FirstHitLvlDown3, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30SetNumberOfTXBurstsMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30SetNumberOfTXBurstsMeter1.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.NumFirePulses, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_Gp30SetNumberOfTXBurstsMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30SetNumberOfTXBurstsMeter2.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.NumFirePulses, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30SetNumberOfTXBurstsMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30SetNumberOfTXBurstsMeter3.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.NumFirePulses, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30SetStartHitMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30SetStartHitMeter1.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.StartHit, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30SetStartHitMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30SetStartHitMeter2.Value;
|
|
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.StartHit, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
|
|
private void btn_Gp30SetStartHitMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30SetStartHitMeter3.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.StartHit, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30SetAmplitudeMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30SetAmplitudeMeter1.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.AmplitudePeakDetectEnd, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30SetAmplitudeMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30SetAmplitudeMeter2.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
|
|
try
|
|
{
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.AmplitudePeakDetectEnd, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_Gp30SetAmplitudeMeter2_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30SetAmplitudeMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30SetAmplitudeMeter3.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.AmplitudePeakDetectEnd, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30SetSamplerateMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30SetSamplerateMeter1.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.SampleRate, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
|
|
}
|
|
private void btn_Gp30SetSamplerateMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30SetSamplerateMeter2.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.SampleRate, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30SetSamplerateMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30SetSamplerateMeter3.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
|
|
try
|
|
{
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.SampleRate, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_Gp30SetSamplerateMeter3_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_Gp30accuResetMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)1;
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.ResetAccumulators, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30accuResetMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)1;
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.ResetAccumulators, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30accuResetMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)1;
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.ResetAccumulators, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30setMeterSizeMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30setMeterSizeMeter1.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.MeterSize, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30setMeterSizeMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30setMeterSizeMeter2.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.MeterSize, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
|
|
private void btn_Gp30setMeterSizeMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30setMeterSizeMeter3.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.MeterSize, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30setLedModeMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30setLedModeMeter1.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.LedMode, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
|
|
}
|
|
private void btn_Gp30setLedModeMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30setLedModeMeter2.Value;
|
|
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.LedMode, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
|
|
private void btn_Gp30setLedModeMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30setLedModeMeter3.Value;
|
|
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.LedMode, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
|
|
private void btn_Gp30getMeterSizeMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.MeterSize);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_Gp30getMeterSizeMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.MeterSize);
|
|
jobToDo.Start();
|
|
}
|
|
|
|
private void btn_Gp30getMeterSizeMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.MeterSize);
|
|
jobToDo.Start();
|
|
}
|
|
|
|
private void btn_Gp30setForwardArrowMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30setForwardArrowMeter1.Value;
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.ForwardArrow, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
|
|
}
|
|
|
|
private void btn_Gp30setForwardArrowMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30setForwardArrowMeter2.Value;
|
|
|
|
DisplayOnTab = SelectedTab.Gp30Meter2;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.ForwardArrow, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
|
|
private void btn_Gp30setForwardArrowMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_Gp30setForwardArrowMeter3.Value;
|
|
|
|
DisplayOnTab = SelectedTab.Gp30Meter3;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.ForwardArrow, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
|
|
private void btn_CommandChannelClearMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
rTB_CommandChannelDecodedMeter1.Clear();
|
|
Display.Gp30ResetMostImportantLabels(Constants.Meter1);
|
|
Display.Gp30ResetLessImportantLabels(Constants.Meter1);
|
|
|
|
nUD_SetFirstLevelUpPath0Meter1.Value = nUD_SetFirstLevelUpPath0Meter1.Minimum;
|
|
nUD_SetFirstLevelUpPath1Meter1.Value = nUD_SetFirstLevelUpPath1Meter1.Minimum;
|
|
nUD_SetFirstLevelUpPath2Meter1.Value = nUD_SetFirstLevelUpPath2Meter1.Minimum;
|
|
nUD_SetFirstLevelDownPath0Meter1.Value = nUD_SetFirstLevelDownPath0Meter1.Minimum;
|
|
nUD_SetFirstLevelDownPath1Meter1.Value = nUD_SetFirstLevelDownPath1Meter1.Minimum;
|
|
nUD_SetFirstLevelDownPath2Meter1.Value = nUD_SetFirstLevelDownPath2Meter1.Minimum;
|
|
nUD_Gp30SetNumberOfTXBurstsMeter1.Value = nUD_Gp30SetNumberOfTXBurstsMeter1.Minimum;
|
|
nUD_Gp30SetStartHitMeter1.Value = nUD_Gp30SetStartHitMeter1.Minimum;
|
|
nUD_Gp30SetAmplitudeMeter1.Value = nUD_Gp30SetAmplitudeMeter1.Minimum;
|
|
nUD_Gp30SetSamplerateMeter1.Value = nUD_Gp30SetSamplerateMeter1.Minimum;
|
|
nUD_Gp30writeCalFactorPath0Meter1.Value = 0;// nUD_SetCalFactor1Meter1.Minimum;
|
|
nUD_Gp30writeCalFactorPath1Meter1.Value = 0;// nUD_SetCalFactor2Meter1.Minimum;
|
|
nUD_Gp30writeCalFactorPath2Meter1.Value = 0; // nUD_SetCalFactor3Meter1.Minimum;
|
|
nUD_Gp30writeZeroOffsetPath0Meter1.Value = 0;// nUD_SetZeroOffset1Meter1.Minimum;
|
|
nUD_Gp30writeZeroOffsetPath1Meter1.Value = 0;// nUD_SetZeroOffset2Meter1.Minimum;
|
|
nUD_Gp30writeZeroOffsetPath2Meter1.Value = 0;// nUD_SetZeroOffset3Meter1.Minimum;
|
|
nUD_Gp30setMeterSizeMeter1.Value = nUD_Gp30setMeterSizeMeter1.Minimum;
|
|
nUD_Gp30setLedModeMeter1.Value = nUD_Gp30setLedModeMeter1.Minimum;
|
|
nUD_Gp30setForwardArrowMeter1.Value = nUD_Gp30setForwardArrowMeter1.Minimum;
|
|
}
|
|
|
|
private void btn_CommandChannelClearMeter2_Click(object sender, EventArgs e)
|
|
{
|
|
rTB_CommandChannelDecodedMeter2.Clear();
|
|
Display.Gp30ResetMostImportantLabels(Constants.Meter2);
|
|
Display.Gp30ResetLessImportantLabels(Constants.Meter2);
|
|
|
|
nUD_SetFirstLevelUpPath0Meter2.Value = nUD_SetFirstLevelUpPath0Meter2.Minimum;
|
|
nUD_SetFirstLevelUpPath1Meter2.Value = nUD_SetFirstLevelUpPath1Meter2.Minimum;
|
|
nUD_SetFirstLevelUpPath2Meter2.Value = nUD_SetFirstLevelUpPath2Meter2.Minimum;
|
|
nUD_SetFirstLevelDownPath0Meter2.Value = nUD_SetFirstLevelDownPath0Meter2.Minimum;
|
|
nUD_SetFirstLevelDownPath1Meter2.Value = nUD_SetFirstLevelDownPath1Meter2.Minimum;
|
|
nUD_SetFirstLevelDownPath2Meter2.Value = nUD_SetFirstLevelDownPath2Meter2.Minimum;
|
|
nUD_Gp30SetNumberOfTXBurstsMeter2.Value = nUD_Gp30SetNumberOfTXBurstsMeter2.Minimum;
|
|
nUD_Gp30SetStartHitMeter2.Value = nUD_Gp30SetStartHitMeter2.Minimum;
|
|
nUD_Gp30SetAmplitudeMeter2.Value = nUD_Gp30SetAmplitudeMeter2.Minimum;
|
|
nUD_Gp30SetSamplerateMeter2.Value = nUD_Gp30SetSamplerateMeter2.Minimum;
|
|
nUD_Gp30writeCalFactorPath0Meter2.Value = 0;
|
|
nUD_Gp30writeCalFactorPath1Meter2.Value = 0;
|
|
nUD_Gp30writeCalFactorPath2Meter2.Value = 0;
|
|
nUD_Gp30writeZeroOffsetPath0Meter2.Value = 0;
|
|
nUD_Gp30writeZeroOffsetPath2Meter2.Value = 0;
|
|
nUD_Gp30writeZeroOffsetPath1Meter2.Value = 0;
|
|
nUD_Gp30setMeterSizeMeter2.Value = nUD_Gp30setMeterSizeMeter2.Minimum;
|
|
nUD_Gp30setLedModeMeter2.Value = nUD_Gp30setLedModeMeter2.Minimum;
|
|
nUD_Gp30setForwardArrowMeter2.Value = nUD_Gp30setForwardArrowMeter2.Minimum;
|
|
}
|
|
|
|
private void btn_CommandChannelClearMeter3_Click(object sender, EventArgs e)
|
|
{
|
|
rTB_CommandChannelDecodedMeter3.Clear();
|
|
Display.Gp30ResetMostImportantLabels(Constants.Meter3);
|
|
Display.Gp30ResetLessImportantLabels(Constants.Meter3);
|
|
|
|
nUD_SetFirstLevelUpPath0Meter3.Value = nUD_SetFirstLevelUpPath0Meter3.Minimum;
|
|
nUD_SetFirstLevelUpPath1Meter3.Value = nUD_SetFirstLevelUpPath1Meter3.Minimum;
|
|
nUD_SetFirstLevelUpPath2Meter3.Value = nUD_SetFirstLevelUpPath2Meter3.Minimum;
|
|
nUD_SetFirstLevelDownPath0Meter3.Value = nUD_SetFirstLevelDownPath0Meter3.Minimum;
|
|
nUD_SetFirstLevelDownPath1Meter3.Value = nUD_SetFirstLevelDownPath1Meter3.Minimum;
|
|
nUD_SetFirstLevelDownPath2Meter3.Value = nUD_SetFirstLevelDownPath2Meter3.Minimum;
|
|
nUD_Gp30SetNumberOfTXBurstsMeter3.Value = nUD_Gp30SetNumberOfTXBurstsMeter3.Minimum;
|
|
nUD_Gp30SetStartHitMeter3.Value = nUD_Gp30SetStartHitMeter3.Minimum;
|
|
nUD_Gp30SetAmplitudeMeter3.Value = nUD_Gp30SetAmplitudeMeter3.Minimum;
|
|
nUD_Gp30SetSamplerateMeter3.Value = nUD_Gp30SetSamplerateMeter3.Minimum;
|
|
nUD_Gp30writeCalFactorPath0Meter3.Value = 0;
|
|
nUD_Gp30writeCalFactorPath1Meter3.Value = 0;
|
|
nUD_Gp30writeCalFactorPath2Meter3.Value = 0;
|
|
nUD_Gp30writeZeroOffsetPath0Meter3.Value = 0;
|
|
nUD_Gp30writeZeroOffsetPath1Meter3.Value = 0;
|
|
nUD_Gp30writeZeroOffsetPath2Meter3.Value = 0;
|
|
nUD_Gp30setMeterSizeMeter3.Value = nUD_Gp30setMeterSizeMeter3.Minimum;
|
|
nUD_Gp30setLedModeMeter3.Value = nUD_Gp30setLedModeMeter3.Minimum;
|
|
nUD_Gp30setForwardArrowMeter3.Value = nUD_Gp30setForwardArrowMeter3.Minimum;
|
|
|
|
}
|
|
#endregion
|
|
#region GP30 numeric up down
|
|
private void nUD_SetFirstLevelUpPath0Meter1_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelUpPath0Meter1.Text = $"{((Double)nUD_SetFirstLevelUpPath0Meter1.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage)}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
private void nUD_SetFirstLevelUpPath0Meter2_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelUpPath0Meter2.Text = $"{((Double)nUD_SetFirstLevelUpPath0Meter2.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage)}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
private void nUD_SetFirstLevelUpPath0Meter3_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelUpPath0Meter3.Text = $"{((Double)nUD_SetFirstLevelUpPath0Meter3.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage)}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_SetFirstLevelUpPath1Meter1_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelUpPath1Meter1.Text = $"{((Double)nUD_SetFirstLevelUpPath1Meter1.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage)}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_SetFirstLevelUpPath1Meter2_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelUpPath1Meter2.Text = $"{((Double)nUD_SetFirstLevelUpPath1Meter2.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_SetFirstLevelUpPath1Meter3_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelUpPath1Meter3.Text = $"{((Double)nUD_SetFirstLevelUpPath1Meter3.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_SetFirstLevelUpPath2Meter1_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelUpPath2Meter1.Text = $"{((Double)nUD_SetFirstLevelUpPath2Meter1.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_SetFirstLevelUpPath2Meter2_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelUpPath2Meter2.Text = $"{((Double)nUD_SetFirstLevelUpPath2Meter2.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{ Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_SetFirstLevelUpPath2Meter3_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelUpPath2Meter3.Text = $"{((Double)nUD_SetFirstLevelUpPath2Meter3.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_SetFirstLevelDownPath0Meter1_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelDownPath0Meter1.Text = $"{((Double)nUD_SetFirstLevelDownPath0Meter1.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_SetFirstLevelDownPath0Meter2_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelDownPath0Meter2.Text = $"{((Double)nUD_SetFirstLevelDownPath0Meter2.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_SetFirstLevelDownPath0Meter3_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelDownPath0Meter3.Text = $"{((Double)nUD_SetFirstLevelDownPath0Meter3.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_SetFirstLevelDownPath1Meter1_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelDownPath1Meter1.Text = $"{((Double)nUD_SetFirstLevelDownPath1Meter1.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_SetFirstLevelDownPath1Meter2_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelDownPath1Meter2.Text = $"{((Double)nUD_SetFirstLevelDownPath1Meter2.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_SetFirstLevelDownPath1Meter3_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelDownPath1Meter3.Text = $"{((Double)nUD_SetFirstLevelDownPath1Meter3.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_SetFirstLevelDownPath2Meter1_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelDownPath2Meter1.Text = $"{((Double)nUD_SetFirstLevelDownPath2Meter1.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_SetFirstLevelDownPath2Meter2_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelDownPath2Meter2.Text = $"{((Double)nUD_SetFirstLevelDownPath2Meter2.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
|
|
private void nUD_SetFirstLevelDownPath2Meter3_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
l_SetFirstLevelDownPath2Meter3.Text = $"{((Double)nUD_SetFirstLevelDownPath2Meter3.Value * Constants.FirstHitLevelFactor).ToString(Formats.FirstHitLevelVoltage, GetGlobalCulture())}{Units.FirstHitLevelVoltage}";
|
|
}
|
|
#endregion
|
|
#endregion
|
|
#endregion
|
|
|
|
private void SetLabelUseSplitcounter(String text)
|
|
{
|
|
if (InvokeRequired)
|
|
{
|
|
Invoke((Action<String>)SetLabelUseSplitcounter, text);
|
|
return;
|
|
}
|
|
|
|
l_Form1Splitcounter.Text = text;
|
|
|
|
}
|
|
|
|
private void SetLabelUseSplitcounterMeter1(String text)
|
|
{
|
|
if (InvokeRequired)
|
|
{
|
|
Invoke((Action<String>)SetLabelUseSplitcounterMeter1, text);
|
|
return;
|
|
}
|
|
|
|
l_SplitcounterMeter1.Text = text;
|
|
|
|
}
|
|
|
|
private void SetLabelUseSplitcounterMeter2(String text)
|
|
{
|
|
if (InvokeRequired)
|
|
{
|
|
Invoke((Action<String>)SetLabelUseSplitcounterMeter2, text);
|
|
return;
|
|
}
|
|
|
|
l_SplitcounterMeter2.Text = text;
|
|
|
|
}
|
|
|
|
private void SetLabelUseSplitcounterMeter3(String text)
|
|
{
|
|
if (InvokeRequired)
|
|
{
|
|
Invoke((Action<String>)SetLabelUseSplitcounterMeter3, text);
|
|
return;
|
|
}
|
|
|
|
l_SplitcounterMeter3.Text = text;
|
|
}
|
|
|
|
private void btn_Gp30readCalFactorPath0Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.CalFactor1);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30readCalFactorPath1Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.CalFactor2);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30readCalFactorPath2Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.CalFactor3);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30readZeroOffsetPath0Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.ZeroOffset1);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30readZeroOffsetPath1Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.ZeroOffset2);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30readZeroOffsetPath2Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.ZeroOffset3);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_Gp30readPercentagePath0Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.FirstHitPercent1);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30readPercentagePath1Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.FirstHitPercent2);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30readPercentagePath2Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.FirstHitPercent3);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30readNumberOfTXBurstsMeter1_Click(object sender, EventArgs e)
|
|
{
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = ReadRegister(CheckMeterConnected(1), Register.Genesisflow.NumFirePulses);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Read from register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30readCalFactorPath0Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.CalFactor1);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30readCalFactorPath1Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.CalFactor2);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30readCalFactorPath2Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.CalFactor3);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30writeCalFactorPath0Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeCalFactorPath0Meter1.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
Gp30TxPayload = Data;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.CalFactor1, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30writeCalFactorPath1Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeCalFactorPath1Meter1.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
Gp30TxPayload = Data;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.CalFactor2, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30writeCalFactorPath2Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeCalFactorPath2Meter1.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
Gp30TxPayload = Data;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.CalFactor3, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30writeZeroOffsetPath0Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeZeroOffsetPath0Meter1.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
Gp30TxPayload = Data;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.ZeroOffset1, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30writeZeroOffsetPath1Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeZeroOffsetPath1Meter1.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
Gp30TxPayload = Data;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.ZeroOffset2, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30writeZeroOffsetPath2Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeZeroOffsetPath2Meter1.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
Gp30TxPayload = Data;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.ZeroOffset3, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_Gp30writePercentagePath0Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writePercentagePath0Meter1.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
Gp30TxPayload = Data;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.FirstHitPercent1, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
|
|
}
|
|
private void btn_Gp30writePercentagePath1Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writePercentagePath1Meter1.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
Gp30TxPayload = Data;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.FirstHitPercent2, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
private void btn_Gp30writePercentagePath2Meter1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writePercentagePath2Meter1.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
DisplayOnTab = SelectedTab.Gp30Meter1;
|
|
Gp30TxPayload = Data;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30ButtonsDisable(true);
|
|
FormControl.DisableTabExceptGp30settings(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.FirstHitPercent3, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30ButtonsDisable(false);
|
|
FormControl.DisableTabExceptGp30settings(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
|
|
}
|
|
private void btn_Gp30readZeroOffsetPath0Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.ZeroOffset1);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30readZeroOffsetPath1Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.CalFactor2);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30readZeroOffsetPath2Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.ZeroOffset3);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30readPercentagePath0Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.FirstHitPercent1);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30readPercentagePath1Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.FirstHitPercent2);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30readPercentagePath2Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
var jobToDo = ReadRegister(CheckMeterConnected(2), Register.Genesisflow.FirstHitPercent3);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30writePercentagePath0Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writePercentagePath0Meter2.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.FirstHitPercent1, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30writePercentagePath1Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writePercentagePath1Meter2.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.FirstHitPercent2, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30writePercentagePath2Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writePercentagePath2Meter2.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.FirstHitPercent3, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30writeCalFactorPath0Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeCalFactorPath0Meter2.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.CalFactor1, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30writeCalFactorPath1Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeCalFactorPath1Meter2.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.CalFactor2, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30writeCalFactorPath2Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeCalFactorPath2Meter2.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.CalFactor3, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30writeZeroOffsetPath0Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeZeroOffsetPath0Meter2.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.ZeroOffset1, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30writeZeroOffsetPath1Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeZeroOffsetPath1Meter2.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.ZeroOffset2, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30writeZeroOffsetPath2Meter2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeZeroOffsetPath2Meter2.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(2), Register.Genesisflow.ZeroOffset3, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30writeCalFactorPath0Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeCalFactorPath0Meter3.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.CalFactor1, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30writeCalFactorPath1Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeCalFactorPath1Meter3.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.CalFactor2, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30writeCalFactorPath2Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeCalFactorPath2Meter3.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.CalFactor3, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30readCalFactorPath2Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.CalFactor3);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30writeZeroOffsetPath0Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeZeroOffsetPath0Meter3.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.ZeroOffset1, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30writeZeroOffsetPath1Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeZeroOffsetPath1Meter3.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.ZeroOffset2, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30writeZeroOffsetPath2Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writeZeroOffsetPath2Meter3.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.ZeroOffset3, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30WritePercentagePath0Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writePercentagePath0Meter3.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.FirstHitPercent1, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30writePercentagePath1Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writePercentagePath1Meter3.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.FirstHitPercent2, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30writePercentagePath2Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data = BitConverter.GetBytes((Int32)nUD_Gp30writePercentagePath2Meter3.Value);
|
|
Byte[] Gp30TxPayload = new Byte[2];
|
|
Gp30TxPayload = Data;
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(3), Register.Genesisflow.FirstHitPercent3, Gp30TxPayload);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
});
|
|
}
|
|
private void btn_Gp30readPercentagePath0Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.FirstHitPercent1);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30ReadPercentagePath1Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.FirstHitPercent2);
|
|
jobToDo.Start();
|
|
}
|
|
private void btn_Gp30readPercentagePath2Meter3_Click(object sender, EventArgs e)
|
|
{
|
|
var jobToDo = ReadRegister(CheckMeterConnected(3), Register.Genesisflow.FirstHitPercent3);
|
|
jobToDo.Start();
|
|
}
|
|
|
|
|
|
|
|
|
|
private void tab_Maintab_Selecting(object sender, TabControlCancelEventArgs e)
|
|
{
|
|
e.Cancel = !e.TabPage.Enabled;
|
|
if (e.TabPage.Name == "tab_Json")
|
|
{
|
|
try
|
|
{
|
|
FormControl.JsonButtonsDisable(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
UInt16 MeterNumber = 1;
|
|
if (cB_SerialConfigMassMassLoggingEn.Checked)
|
|
{
|
|
if (rB_JsonMeter1.Checked)
|
|
MeterNumber = 1;
|
|
if (rB_JsonMeter2.Checked)
|
|
MeterNumber = 2;
|
|
if (rB_JsonMeter3.Checked)
|
|
MeterNumber = 3;
|
|
}
|
|
else
|
|
MeterNumber = 1;
|
|
|
|
WaitForBackgroundWorkers();
|
|
lB_JsonItems.Items.Clear();
|
|
|
|
var meter = CheckMeterConnected(MeterNumber);
|
|
|
|
foreach (var item in meter.GetRegisters())
|
|
{
|
|
lB_JsonItems.Items.Add($"{item.Key.GetIdent()}");
|
|
}
|
|
|
|
FormControl.JsonButtonsDisable(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_JsonUpdate_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Update failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.JsonButtonsDisable(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private void btn_SideSetNumberOfTXBursts_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SideSetNumberOfTXBursts.Value;
|
|
DisplayOnTab = SelectedTab.None;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30SideButtonsDisable(true);
|
|
FormControl.DisableTabAll(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.NumFirePulses, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
#region Error
|
|
ErrorLog.Log(LogErrReason.Exception(), "btn_SideSetNumberOfTXBursts_Click() failed", $"0x{ex.HResult.ToString("X", GetGlobalCulture())}", String.Empty);
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SideSetStartHit_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SideSetStartHit.Value;
|
|
DisplayOnTab = SelectedTab.None;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30SideButtonsDisable(true);
|
|
FormControl.DisableTabAll(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.StartHit, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SideSetAmplitude_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4];
|
|
Data[0] = (Byte)nUD_SideSetAmplitude.Value;
|
|
DisplayOnTab = SelectedTab.None;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30SideButtonsDisable(true);
|
|
FormControl.DisableTabAll(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.AmplitudePeakDetectEnd, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SideSetSamplerate_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4];
|
|
Data[0] = (Byte)nUD_SideSetSamplerate.Value;
|
|
DisplayOnTab = SelectedTab.None;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30SideButtonsDisable(true);
|
|
FormControl.DisableTabAll(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.SampleRate, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SideSetLedMode_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4];
|
|
Data[0] = (Byte)nUD_SideSetLedMode.Value;
|
|
DisplayOnTab = SelectedTab.None;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30SideButtonsDisable(true);
|
|
FormControl.DisableTabAll(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.LedMode, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
|
|
}
|
|
|
|
private void btn_SidePercentagePath0_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SideSetPercentPath0.Value;
|
|
DisplayOnTab = SelectedTab.None;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30SideButtonsDisable(true);
|
|
FormControl.DisableTabAll(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.FirstHitPercent1, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SidePercentagePath1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SideSetPercentPath1.Value;
|
|
DisplayOnTab = SelectedTab.None;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30SideButtonsDisable(true);
|
|
FormControl.DisableTabAll(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.FirstHitPercent2, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SidePercentagePath2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SideSetPercentPath2.Value;
|
|
DisplayOnTab = SelectedTab.None;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30SideButtonsDisable(true);
|
|
FormControl.DisableTabAll(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.FirstHitPercent3, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void tab_Maintab_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
if (TabControl.Equals(tab_Maintab.SelectedTab, tab_RawData) || TabControl.Equals(tab_Maintab.SelectedTab, tab_Graph) || TabControl.Equals(tab_Maintab.SelectedTab, tab_DataDecoding2))
|
|
{
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
}
|
|
else
|
|
{
|
|
FormControl.Gp30SideButtonsDisable(true);
|
|
}
|
|
}
|
|
|
|
private void btn_SideOffsetPath0_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SideSetOffsetPath0.Value;
|
|
DisplayOnTab = SelectedTab.None;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30SideButtonsDisable(true);
|
|
FormControl.DisableTabAll(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.ZeroOffset1, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SideOffsetPath1_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SideSetOffsetPath1.Value;
|
|
DisplayOnTab = SelectedTab.None;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30SideButtonsDisable(true);
|
|
FormControl.DisableTabAll(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.ZeroOffset2, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SideOffsetPath2_Click(object sender, EventArgs e)
|
|
{
|
|
Byte[] Data = new Byte[4] { 0, 0, 0, 0 };
|
|
Data[0] = (Byte)nUD_SideSetOffsetPath2.Value;
|
|
DisplayOnTab = SelectedTab.None;
|
|
|
|
try
|
|
{
|
|
FormControl.Gp30SideButtonsDisable(true);
|
|
FormControl.DisableTabAll(true);
|
|
FormControl.DataLoggingButtonsDisable(true);
|
|
|
|
var jobToDo = WriteRegister<Byte[]>(CheckMeterConnected(1), Register.Genesisflow.ZeroOffset3, Data);
|
|
jobToDo.Start();
|
|
jobToDo.ContinueWith((resTask) =>
|
|
{
|
|
if (resTask.Result)
|
|
MessageBox.Show("Write to register successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
else
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
});
|
|
}
|
|
catch (Exception)
|
|
{
|
|
#region Error
|
|
MessageBox.Show("Write to register failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
FormControl.Gp30SideButtonsDisable(false);
|
|
FormControl.DisableTabAll(false);
|
|
FormControl.DataLoggingButtonsDisable(false);
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
private void btn_SerialCfg_DataOpen_Click(object sender, EventArgs e)
|
|
{
|
|
pB_Bubbles.Visible = true;
|
|
gB_SerialCfg_Data.Enabled = false;
|
|
gBSerialCfgCommand.Enabled = false;
|
|
FormControl.DisableTabExceptSerialConfig(true);
|
|
|
|
if (String.IsNullOrEmpty(lB_SerialCfg_DataComSelect.Text))
|
|
{
|
|
pB_Bubbles.Visible = false;
|
|
MessageBox.Show("COMPORT settings not valid", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
gB_SerialCfg_Data.Enabled = true;
|
|
gBSerialCfgCommand.Enabled = true;
|
|
FormControl.DisableTabExceptSerialConfig(false);
|
|
return;
|
|
}
|
|
|
|
|
|
#region LED data
|
|
try
|
|
{
|
|
|
|
serialPortDataMeter1.BaudRate = 115200;
|
|
serialPortDataMeter1.PortName = lB_SerialCfg_DataComSelect.Text;
|
|
serialPortDataMeter1.Parity = Parity.None;
|
|
serialPortDataMeter1.StopBits = StopBits.One;
|
|
serialPortDataMeter1.DataBits = 8;
|
|
if (!serialPortDataMeter1.IsOpen)
|
|
{
|
|
serialPortDataMeter1.DataReceived += new SerialDataReceivedEventHandler(serialPortDataMeter1DataReceived);
|
|
serialPortDataMeter1.Open();
|
|
pB_Bubbles.Visible = false;
|
|
MessageBox.Show("Serial Port opened");
|
|
FormControl.DisableTabExceptSerialConfig(false);
|
|
gB_SerialCfg_Data.Enabled = true;
|
|
gBSerialCfgCommand.Enabled = true;
|
|
btn_SerialCfg_DataClose.Enabled = true;
|
|
btn_SerialCfg_DataOpen.Enabled = false;
|
|
}
|
|
else
|
|
{
|
|
|
|
pB_Bubbles.Visible = false;
|
|
MessageBox.Show("Serial Port is already open");
|
|
FormControl.DisableTabExceptSerialConfig(false);
|
|
gB_SerialCfg_Data.Enabled = true;
|
|
gBSerialCfgCommand.Enabled = true;
|
|
btn_SerialCfg_DataClose.Enabled = true;
|
|
btn_SerialCfg_DataOpen.Enabled = false;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
pB_Bubbles.Visible = false;
|
|
MessageBox.Show("Serial Port could not be opened");
|
|
FormControl.DisableTabExceptSerialConfig(false);
|
|
gB_SerialCfg_Data.Enabled = true;
|
|
gBSerialCfgCommand.Enabled = true;
|
|
btn_SerialCfg_DataClose.Enabled = false;
|
|
btn_SerialCfg_DataOpen.Enabled = true;
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
private void btn_SerialCfg_DataClose_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (serialPortDataMeter1.IsOpen)
|
|
{
|
|
gB_SerialCfg_Data.Enabled = false;
|
|
gBSerialCfgCommand.Enabled = false;
|
|
btn_SerialCfg_DataOpen.Enabled = false;
|
|
//serialPortDataMeter1.DataReceived -= CurrentMeter_OnRequestdataRecived;
|
|
serialPortDataMeter1.DataReceived -= serialPortDataMeter1DataReceived;
|
|
Misc.WaitNSeconds(1);
|
|
while (serialPortDataMeter1.IsOpen)
|
|
serialPortDataMeter1.Close();
|
|
MessageBox.Show("Serial Port closed");
|
|
btn_SerialCfg_DataClose.Enabled = false;
|
|
btn_SerialCfg_DataOpen.Enabled = true;
|
|
gB_SerialCfg_Data.Enabled = true;
|
|
gBSerialCfgCommand.Enabled = true;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
MessageBox.Show("Serial Port could not be closed");
|
|
}
|
|
}
|
|
|
|
private void tab_SerialConfig_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|
|
|