1098 lines
42 KiB
C#
1098 lines
42 KiB
C#
using System;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using GenesisDisplayTool;
|
|
using System.Globalization;
|
|
|
|
using System.IO;
|
|
using System.IO.Ports;
|
|
using Xylem.Common.Hardware.Interfaces.Ports.SerialPorts;
|
|
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
|
|
using Newtonsoft.Json;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.DataPackages.MeasurementRecords;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisConfig;
|
|
|
|
namespace GenesisZeroFlow
|
|
{
|
|
|
|
|
|
public partial class frmTempCalibration : Form
|
|
{
|
|
private String dataToLog = String.Empty;
|
|
public void SetDataToLog(String data)
|
|
{
|
|
dataToLog = data;
|
|
}
|
|
public String GetDataToLog()
|
|
{
|
|
return (String)dataToLog.Clone();
|
|
}
|
|
|
|
public Type TransferType(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);
|
|
}
|
|
public String GetTransferMode()
|
|
{
|
|
String temp = String.Empty;
|
|
|
|
if (InvokeRequired)
|
|
{
|
|
lBTransferMode.Invoke(new Action(() =>
|
|
{
|
|
temp = lBTransferMode.Text;
|
|
}));
|
|
|
|
|
|
}
|
|
return lBTransferMode.Text;
|
|
}
|
|
|
|
public String ConvertTransferMode(String text)
|
|
{
|
|
|
|
if (!String.IsNullOrEmpty(text))
|
|
{
|
|
if (String.Equals(text, "RfidComPort"))
|
|
return typeof(RfidSerialPort).ToString();
|
|
if (String.Equals(text, "SerialComPort"))
|
|
return typeof(UartSerialPort).ToString();
|
|
if (String.Equals(text, "IrdaComPort"))
|
|
return typeof(IrdaSerialPort).ToString();
|
|
return typeof(RfidSerialPort).ToString(); ;
|
|
}
|
|
else
|
|
return typeof(RfidSerialPort).ToString(); ;
|
|
}
|
|
|
|
public String GetPassword()
|
|
{
|
|
String temp = String.Empty;
|
|
|
|
if (InvokeRequired)
|
|
{
|
|
tBPassword.Invoke(new Action(() =>
|
|
{
|
|
temp = tBPassword.Text;
|
|
}));
|
|
|
|
return temp;
|
|
}
|
|
return tBPassword.Text;
|
|
}
|
|
public String GetSerialPortCmdChannel()
|
|
{
|
|
String temp = String.Empty;
|
|
|
|
if (InvokeRequired)
|
|
{
|
|
lB_Comport_CmdInterface.Invoke(new Action(() =>
|
|
{
|
|
temp = lB_Comport_CmdInterface.Text;
|
|
}));
|
|
|
|
return temp;
|
|
}
|
|
return lB_Comport_CmdInterface.Text;
|
|
}
|
|
|
|
|
|
MeterBatch GlobalMeterBatch = new MeterBatch();
|
|
Boolean[] SerialPortOpenFlag = new Boolean[2] { false, false };
|
|
Boolean PreparationFailed = false;
|
|
Boolean CompletionEnable = false;
|
|
Boolean EmptyPipeCheckEnable = false;
|
|
String ModeString = String.Empty;
|
|
public Boolean ThirdFormOpenIndicator = false;
|
|
|
|
public Boolean CompletionFailed { get; private set; }
|
|
public Boolean EmptyPipeCheckFailed { get; private set; }
|
|
public Boolean TempCalEnable { get; private set; }
|
|
public Boolean TempCalFailed { get; private set; }
|
|
private Boolean EnableIndicatorTempTest = false;
|
|
private Boolean LoggingIndicatorTempTest = false;
|
|
public void SetEnableIndicatorTempTest(Boolean value)
|
|
{
|
|
EnableIndicatorTempTest = value;
|
|
}
|
|
public void SetLoggingIndicatorTempTest(Boolean value)
|
|
{
|
|
LoggingIndicatorTempTest = value;
|
|
}
|
|
|
|
public Boolean GetLoggingIndicatorTempTest()
|
|
{
|
|
return LoggingIndicatorTempTest;
|
|
}
|
|
private Boolean EnableIndicatorEmptyPipeTest = false;
|
|
public void SetEnableIndicatorEmptyPipeTest(Boolean value)
|
|
{
|
|
EnableIndicatorEmptyPipeTest = value;
|
|
}
|
|
private Int32[] LineCounterEmptyPipeTest = new Int32[Constants.NumberOfPaths];
|
|
public Int32[] GetLineCounterEmptyPipeTest()
|
|
{
|
|
return (Int32[])LineCounterEmptyPipeTest;
|
|
}
|
|
public void SetLineCounterEmptyPipeTest(Int32 value, UInt16 path)
|
|
{
|
|
LineCounterEmptyPipeTest[path] = value;
|
|
}
|
|
private CalibrationRecord[] DecodedAllMeters = new CalibrationRecord[Constants.NumberOfPaths];
|
|
public CalibrationRecord[] GetDecodedAllMeters()
|
|
{
|
|
return (CalibrationRecord[])DecodedAllMeters.Clone();
|
|
}
|
|
|
|
public CultureInfo GetGlobalCulture()
|
|
{
|
|
return CultureInfo.CreateSpecificCulture("en-US");
|
|
}
|
|
|
|
public frmTempCalibration()
|
|
{
|
|
InitializeComponent();
|
|
_frmTempCalibration = this;
|
|
}
|
|
|
|
public static frmTempCalibration _frmTempCalibration;
|
|
public Boolean WaitForTemperatureFieldTempCal = false;
|
|
private Int32[] ToFTempOffset = new Int32[Constants.NumberOfPaths];
|
|
public void SetToFTempOffset(UInt16 path, Int32 data)
|
|
{
|
|
ToFTempOffset[path] = data;
|
|
}
|
|
private Int32[][] ZeroFlowOffset = new Int32[Constants.NumberOfMeters][];
|
|
public void SetWaitForTemperatureFieldTempCal(Boolean value)
|
|
{
|
|
WaitForTemperatureFieldTempCal = value;
|
|
}
|
|
private Int32[] LineCounterTemperatureTest = new Int32[Constants.NumberOfPaths];
|
|
public Int32[] GetLineCounterTemperatureTest()
|
|
{
|
|
return (Int32[])LineCounterTemperatureTest;
|
|
}
|
|
public void SetLineCounterTemperatureTest(Int32 value, UInt16 path)
|
|
{
|
|
LineCounterTemperatureTest[path] = value;
|
|
}
|
|
|
|
public Boolean GetAdjustmentSelectedStatus()
|
|
{
|
|
Boolean temp = false;
|
|
if (InvokeRequired)
|
|
{
|
|
rB_Adjustment.Invoke(new Action(() =>
|
|
{
|
|
temp = rB_Adjustment.Checked;
|
|
}));
|
|
|
|
return temp;// rB_Adjustment.Checked;
|
|
}
|
|
return rB_Adjustment.Checked;
|
|
}
|
|
|
|
public Boolean GetMeasurementSelectedStatus()
|
|
{
|
|
Boolean temp = false;
|
|
if (InvokeRequired)
|
|
{
|
|
rB_Adjustment.Invoke(new Action(() =>
|
|
{
|
|
temp = rB_Measurement.Checked;
|
|
}));
|
|
|
|
return rB_Measurement.Checked;
|
|
}
|
|
return rB_Measurement.Checked;
|
|
|
|
}
|
|
public void SetControlElements(Boolean enabled)
|
|
{
|
|
if (enabled)
|
|
{
|
|
pB_Bubbles1.Visible = false;
|
|
btn_TempCal_Detect.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
btn_TempCal_Detect.Enabled = false;
|
|
btn_TempCal_Start.Enabled = false;
|
|
}
|
|
}
|
|
|
|
public String PcbId = String.Empty;
|
|
private void btn_ZeroFlowCal_Detect_Click(object sender, EventArgs e)
|
|
{
|
|
CultureInfo Culture = GetGlobalCulture();
|
|
String TransferMode = GetTransferMode();
|
|
|
|
if (GlobalMeterBatch.ListOfMeters.Any())
|
|
GlobalMeterBatch.RemoveAllMeters();
|
|
else
|
|
GlobalMeterBatch = new MeterBatch();
|
|
|
|
try
|
|
{
|
|
if (cB_SinglePath.Checked)
|
|
Constants.NumberOfPaths = 1;
|
|
else
|
|
Constants.NumberOfPaths = 3;
|
|
|
|
PortConfig Configuration = new Xylem.Common.Hardware.WaterMeter.Genesis.GenesisConfig.PortConfig();
|
|
|
|
var requestPort = new PortConfig()
|
|
{
|
|
PortName = lB_Comport_CmdInterface.Text,
|
|
Type = ConvertTransferMode(TransferMode)
|
|
};
|
|
var streamingPort = new PortConfig()
|
|
{
|
|
PortName = lB_Comport_DataInterface.Text,
|
|
Type = typeof(UartSerialPort).ToString()
|
|
};
|
|
|
|
GlobalMeterBatch.AddMeter(new ZeroFlowGenesisMeter(1, requestPort, streamingPort, false));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
DisplayTempCal.SetProgressPanel(StatusPanelItems.None);
|
|
DisplayTempCal.DebugMessage("APPLICATION:\t\t Serial port opening failed\n", Culture);
|
|
DisplayTempCal.StatusLabel("Press 'PREPARE'");
|
|
MessageBox.Show("No valid COMPORT", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
return;
|
|
}
|
|
|
|
foreach (var generalMeter in GlobalMeterBatch.ListOfMeters)
|
|
{
|
|
if (generalMeter is ZeroFlowGenesisMeter)
|
|
{
|
|
var Meter = generalMeter as ZeroFlowGenesisMeter;
|
|
//Meter.LogOnEnable = SerialPortOpenFlag[Meter.Slot - 1] & SerialPortOpenFlag[(Meter.Slot - 1) + Constants.NumberOfMeters];
|
|
Meter.LogOnEnable = SerialPortOpenFlag[Meter.Slot - 1] & SerialPortOpenFlag[(Meter.Slot - 1) + 1];
|
|
Meter.LoginFailed = false;
|
|
Meter.PreparationFailed = false;
|
|
Meter.AmplitudeFailed = false;
|
|
Meter.ZeroFlowOffsetFailed = false;
|
|
Meter.AmplitudeFailed = false;
|
|
Meter.CompletionFailed = false;
|
|
Meter.Ok = false;
|
|
Meter.EmptyPipeCheckEnable = false;
|
|
Meter.EmptyPipeCheckFailed = false;
|
|
}
|
|
}
|
|
|
|
#region Definitions and initializations
|
|
Boolean[] Ok = new Boolean[2];
|
|
|
|
btn_TempCal_Start.Enabled = false;
|
|
#endregion
|
|
#region Bubbles
|
|
pB_Bubbles1.Visible = true;
|
|
#endregion
|
|
#region Visual indication 'PREPARE'
|
|
frmTempCalibration.DisplayTempCal.SetProgressPanel(StatusPanelItems.Detect);
|
|
frmTempCalibration.DisplayTempCal.StatusLabel("Wait until PREPARATION has finished");
|
|
|
|
foreach (var generalMeter in GlobalMeterBatch.ListOfMeters)
|
|
{
|
|
if (generalMeter is ZeroFlowGenesisMeter)
|
|
{
|
|
var Meter = generalMeter as ZeroFlowGenesisMeter;
|
|
Ok[(Meter.Slot - 1)] = Meter.CheckRequestPort();
|
|
Ok[(Meter.Slot - 1) + 1] = Meter.CheckStreamingPort();
|
|
}
|
|
}
|
|
|
|
DisplayTempCal.ConnectionStatus(Ok);
|
|
SerialPortOpenFlag = Ok;
|
|
#endregion
|
|
DisplayTempCal.DebugMessage("APPLICATION:\t\t Serial port opening successful\n", Culture);
|
|
DisplayTempCal.StatusLabel("Press 'START' or repeat 'PREPARE'");
|
|
btn_TempCal_Start.Enabled = true;
|
|
pB_Bubbles1.Visible = false;
|
|
}
|
|
|
|
private async Task<bool> Preparation(CultureInfo culture, bool MeterEnable)
|
|
{
|
|
#region Preparation
|
|
|
|
PreparationFailed = await Task.Run(() =>
|
|
{
|
|
return PreparationSequences.TotalTempCal(GlobalMeterBatch,
|
|
(UInt16)nUD_SettingsPreparationMetersize.Value, 0, 0, 0, culture);
|
|
});
|
|
|
|
|
|
Boolean StopSequence = false;
|
|
|
|
var Ok = DisplayGetSequenceResult(MeterEnable, PreparationFailed, "PREPARATION sequence",
|
|
out StopSequence);
|
|
if (StopSequence)
|
|
{
|
|
DisplayTempCal.MeterStatusGreenRed(false, true);
|
|
DisplayTempCal.SetProgressPanel(StatusPanelItems.None);
|
|
SetControlElements(true);
|
|
gB_Mode.Enabled = true;
|
|
btn_Save.Enabled = true;
|
|
btn_Clear.Enabled = true;
|
|
return false;
|
|
}
|
|
|
|
DisplayTempCal.MeterStatusGreenRed(true, true);
|
|
|
|
#endregion
|
|
|
|
return true;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
private void TempCal_Start(String password, String transferMode, String portCmdChannel, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit, CultureInfo culture)
|
|
{
|
|
#region Definitions and initializations
|
|
const UInt16 PasswordLength = 12;
|
|
Boolean MeterEnable = false;
|
|
|
|
pB_Bubbles1.Visible = true;
|
|
DisplayTempCal.TemperatureLabelsForm1Visible(rB_Adjustment.Checked);
|
|
gB_Mode.Enabled = false;
|
|
gB_Setup.Enabled = false;
|
|
btn_Save.Enabled = false;
|
|
btn_Clear.Enabled = false;
|
|
if (rB_Adjustment.Checked)
|
|
ModeString = "TEMPERATURE ADJUSTMENT";
|
|
else
|
|
ModeString = "TEMPERATURE MEASUREMENT";
|
|
gB_SetTemperature.Text = ModeString;
|
|
#endregion
|
|
#region Check password
|
|
DisplayTempCal.StatusLabel("Wait until LOGIN has finished");
|
|
Misc.WaitNMilliseconds(100);
|
|
SetControlElements(false);
|
|
DisplayTempCal.SetProgressPanel(StatusPanelItems.Prepare);
|
|
|
|
if (!GlobalMeterBatch.ListOfMeters.Any())
|
|
{
|
|
MessageBox.Show("No METER selected", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
DisplayTempCal.SetProgressPanel(StatusPanelItems.None);
|
|
gB_Mode.Enabled = true;
|
|
SetControlElements(true);
|
|
gB_Setup.Enabled = true;
|
|
btn_Save.Enabled = true;
|
|
btn_Clear.Enabled = true;
|
|
return;
|
|
}
|
|
#endregion
|
|
#region Preparation
|
|
if (!String.IsNullOrEmpty(password))
|
|
{
|
|
if (!Misc.OnlyHexInString(password) || (password.Count() < PasswordLength))
|
|
{
|
|
DisplayTempCal.DebugMessage("APPLICATION:\t\t Password invalid\n", culture);
|
|
MessageBox.Show("Password invalid");
|
|
DisplayTempCal.MeterStatusGreenRed(false, true);
|
|
DisplayTempCal.SetProgressPanel(StatusPanelItems.None);
|
|
SetControlElements(true);
|
|
gB_Setup.Enabled = true;
|
|
btn_Save.Enabled = true;
|
|
btn_Clear.Enabled = true;
|
|
return;
|
|
}
|
|
}
|
|
#region LOGIN
|
|
foreach (var item in GlobalMeterBatch.ListOfMeters)
|
|
{
|
|
if (item is ZeroFlowGenesisMeter)
|
|
{
|
|
var Meter = (ZeroFlowGenesisMeter)item;
|
|
MeterEnable = true;
|
|
Boolean LoginOK = false;
|
|
Task<Boolean> LoginTask = Task.Run(() =>
|
|
{
|
|
try
|
|
{
|
|
if (String.IsNullOrEmpty(password))
|
|
LoginOK = Meter.Login();
|
|
else
|
|
LoginOK = Meter.Login(password);
|
|
}
|
|
catch
|
|
{
|
|
LoginOK = false;
|
|
}
|
|
return LoginOK;
|
|
});
|
|
|
|
while (!TaskStatus.Equals(LoginTask.Status, TaskStatus.RanToCompletion))
|
|
{
|
|
DisplayTempCal.DebugMessage("COMMAND INTERFACE:\t Performing LOGIN\n", culture);
|
|
Misc.WaitNSeconds(1, true);
|
|
}
|
|
try
|
|
{
|
|
//if (!Meter.Login(Password))
|
|
if (!LoginOK)
|
|
{
|
|
DisplayTempCal.MeterStatusGreenRed(false, true);
|
|
DisplayTempCal.DebugMessage("APPLICATION:\t\t LOGIN failed\n", culture);
|
|
DisplayTempCal.DebugMessage(Debugmessages.Line, culture);
|
|
DisplayTempCal.SetProgressPanel(StatusPanelItems.None);
|
|
SetControlElements(true);
|
|
gB_Setup.Enabled = true;
|
|
btn_Save.Enabled = true;
|
|
btn_Clear.Enabled = true;
|
|
gB_Mode.Enabled = true;
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
DisplayTempCal.DebugMessage("APPLICATION:\t\t LOGIN successful\n", culture);
|
|
DisplayTempCal.DebugMessage(Debugmessages.Line, culture);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
DisplayTempCal.MeterStatusGreenRed(false, true);
|
|
DisplayTempCal.DebugMessage("APPLICATION:\t\t LOGIN failed\n", culture);
|
|
DisplayTempCal.DebugMessage(Debugmessages.Line, culture);
|
|
DisplayTempCal.SetProgressPanel(StatusPanelItems.None);
|
|
SetControlElements(true);
|
|
gB_Setup.Enabled = true;
|
|
btn_Save.Enabled = true;
|
|
btn_Clear.Enabled = true;
|
|
gB_Mode.Enabled = true;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
DisplayTempCal.SetProgressPanel(StatusPanelItems.Prepare);
|
|
DisplayTempCal.StatusLabel("Wait until PREPARATION has finished");
|
|
|
|
#region add com port listener
|
|
foreach (var item in GlobalMeterBatch.ListOfMeters)
|
|
{
|
|
if (item is ZeroFlowGenesisMeter)
|
|
{
|
|
((ZeroFlowGenesisMeter)item).OnZeroFlowRecordIsDecoded += frmTempCal_OnZeroFlowRecordIsDecoded;
|
|
((ZeroFlowGenesisMeter)item).StartRecordData();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
Preparation(culture, MeterEnable)
|
|
.ContinueWith(async tPrep => await doEmptyPipeCheckEnable(tPrep.Result, culture)
|
|
.ContinueWith(async tWait => await doWait(tWait.Result)
|
|
.ContinueWith(async tBubble => await doBubble(tBubble.Result)
|
|
.ContinueWith(async tTempCal => await doTempCalibration(tTempCal.Result, upperTempLimit, lowerTempLimit, tempDeviationLimit, culture)
|
|
.ContinueWith(async tCompletion => await doCompletion(tCompletion.Result, culture)
|
|
.ContinueWith(async tBubbleAfter => await doBubble(tBubbleAfter.Result)
|
|
))))));
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
private async Task<bool> doCompletion(bool Ok, CultureInfo culture)
|
|
{
|
|
if (!Ok)
|
|
{
|
|
DisplayTempCal.DebugMessage($"APPLICATION:\t\t {ModeString} sequence skipped\n", culture);
|
|
DisplayTempCal.DebugMessage(Debugmessages.Line, culture);
|
|
MessageBox.Show($"{ModeString} sequence skipped", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
setGuiToDone();
|
|
return false;
|
|
}
|
|
#region Completion
|
|
CompletionEnable = Ok;
|
|
DisplayTempCal.SetProgressPanel(StatusPanelItems.Completion);
|
|
DisplayTempCal.StatusLabel("Wait until COMPLETION has finished");
|
|
|
|
var TaskCompletion = Task<bool>.Run(() =>
|
|
{
|
|
return CompletionSequences.TotalTempCal(GlobalMeterBatch, CompletionEnable, culture);
|
|
});
|
|
CompletionFailed = await TaskCompletion;
|
|
var StopSequence = false;
|
|
|
|
Ok = DisplayGetSequenceResult(CompletionEnable, CompletionFailed, "COMPLETION sequence", out StopSequence);
|
|
if (StopSequence)
|
|
{
|
|
DisplayTempCal.MeterStatusGreenRed(false, true);
|
|
DisplayTempCal.SetProgressPanel(StatusPanelItems.None);
|
|
DisplayTempCal.StatusLabel("Press 'PREPARE'");
|
|
DisplayTempCal.DebugMessage($"APPLICATION:\t\t {ModeString} sequence failed\n", culture);
|
|
DisplayTempCal.DebugMessage(Debugmessages.Line, culture);
|
|
MessageBox.Show($"{ModeString} sequence failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
SetControlElements(true);
|
|
gB_Mode.Enabled = true;
|
|
gB_Setup.Enabled = true;
|
|
btn_Save.Enabled = true;
|
|
btn_Clear.Enabled = true;
|
|
return false;
|
|
}
|
|
DisplayTempCal.MeterStatusGreenYellow(false, true);
|
|
DisplayTempCal.DebugMessage($"APPLICATION:\t\t {ModeString} sequence successful\n", culture);
|
|
DisplayTempCal.DebugMessage(Debugmessages.Line, culture);
|
|
MessageBox.Show($"{ModeString} sequence successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
setGuiToDone();
|
|
|
|
|
|
return true;
|
|
|
|
#endregion
|
|
}
|
|
|
|
private void setGuiToDone()
|
|
{
|
|
DisplayTempCal.StatusLabel("Press 'PREPARE'");
|
|
DisplayTempCal.SetProgressPanel(StatusPanelItems.None);
|
|
|
|
Invoke(new Action(() =>
|
|
{
|
|
SetControlElements(true);
|
|
gB_Mode.Enabled = true;
|
|
gB_Setup.Enabled = true;
|
|
|
|
btn_Save.Enabled = true;
|
|
btn_Clear.Enabled = true;
|
|
|
|
}));
|
|
}
|
|
|
|
private async Task<bool> doTempCalibration(bool Ok, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit, CultureInfo culture)
|
|
{
|
|
if (!Ok)
|
|
{
|
|
return false;
|
|
}
|
|
#region Temperature calibration
|
|
TempCalEnable = Ok;
|
|
var TaskTemp = Task<bool>.Run(() =>
|
|
{
|
|
return TempCalibrationSequences.TotalTempCal(GlobalMeterBatch, TempCalEnable, GetAdjustmentSelectedStatus(), upperTempLimit, lowerTempLimit, tempDeviationLimit, culture, this);
|
|
});
|
|
|
|
|
|
|
|
TempCalFailed = await TaskTemp;
|
|
|
|
if (TempCalFailed)
|
|
{
|
|
DisplayTempCal.MeterStatusGreenRed(false, true);
|
|
DisplayTempCal.SetProgressPanel(StatusPanelItems.None);
|
|
SetControlElements(true);
|
|
gB_Mode.Enabled = true;
|
|
gB_Setup.Enabled = true;
|
|
btn_Save.Enabled = true;
|
|
btn_Clear.Enabled = true;
|
|
return false;
|
|
}
|
|
DisplayTempCal.MeterStatusGreenRed(true, true);
|
|
return true;
|
|
|
|
#endregion
|
|
|
|
}
|
|
|
|
private async Task<bool> doBubble(bool Ok)
|
|
{
|
|
if (!Ok)
|
|
{
|
|
return false;
|
|
}
|
|
#region Bubbles
|
|
Invoke(new Action(() =>
|
|
{
|
|
pB_Bubbles1.Visible = true;
|
|
}));
|
|
|
|
await Task.Run(() => Misc.WaitNSeconds(1, true));
|
|
Invoke(new Action(() =>
|
|
{
|
|
pB_Bubbles1.Visible = false;
|
|
}));
|
|
return Ok;
|
|
#endregion
|
|
}
|
|
|
|
|
|
private async Task<bool> doWait(bool Ok)
|
|
{
|
|
if (!Ok)
|
|
{
|
|
return false;
|
|
}
|
|
#region Wait for two minutes
|
|
var StopSequence = false;
|
|
DisplayGetSequenceResult(EmptyPipeCheckEnable, EmptyPipeCheckFailed, "WAIT FOR STABILIZATION sequence", out StopSequence);
|
|
var TaskWait = Task.Run(() =>
|
|
{
|
|
DisplayTempCal.WaitForStabilizationTempCal(Ok, StopSequence, 2);
|
|
});
|
|
|
|
|
|
|
|
|
|
await TaskWait;
|
|
if (StopSequence)
|
|
{
|
|
DisplayTempCal.MeterStatusGreenRed(false, true);
|
|
DisplayTempCal.SetProgressPanel(StatusPanelItems.None);
|
|
SetControlElements(true);
|
|
gB_Mode.Enabled = true;
|
|
gB_Setup.Enabled = true;
|
|
btn_Save.Enabled = true;
|
|
btn_Clear.Enabled = true;
|
|
return false;
|
|
}
|
|
DisplayTempCal.MeterStatusGreenRed(true, true);
|
|
return Ok;
|
|
|
|
#endregion
|
|
}
|
|
|
|
private async Task<bool> doEmptyPipeCheckEnable(bool result, CultureInfo culture)
|
|
{
|
|
if (!result)
|
|
{
|
|
return false;
|
|
}
|
|
#region Empty pipe mode check
|
|
EmptyPipeCheckEnable = result;
|
|
|
|
var TaskEmpty = Task<bool>.Run(() =>
|
|
{
|
|
return !EmptyPipeCheckSequences.TotalTempCal(EmptyPipeCheckEnable, GlobalMeterBatch, culture);
|
|
});
|
|
|
|
|
|
EmptyPipeCheckFailed = await TaskEmpty;
|
|
bool StopSequence = false;
|
|
DisplayGetSequenceResult(EmptyPipeCheckEnable, EmptyPipeCheckFailed, "EMPTY PIPE CHECK sequence", out StopSequence);
|
|
if (StopSequence)
|
|
{
|
|
DisplayTempCal.MeterStatusGreenRed(false, true);
|
|
DisplayTempCal.SetProgressPanel(StatusPanelItems.None);
|
|
SetControlElements(true);
|
|
gB_Mode.Enabled = true;
|
|
btn_Save.Enabled = true;
|
|
btn_Clear.Enabled = true;
|
|
|
|
}
|
|
DisplayTempCal.MeterStatusGreenRed(true, true);
|
|
#endregion
|
|
|
|
return EmptyPipeCheckFailed;
|
|
}
|
|
|
|
|
|
private void btn_TempCal_Start_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
|
|
|
|
|
|
CultureInfo Culture = GetGlobalCulture();
|
|
String Password = GetPassword();
|
|
String TransferMode = GetTransferMode();
|
|
String SerialPortCmdChannel = GetSerialPortCmdChannel();
|
|
|
|
const Double UpperTempLimit = 35;
|
|
const Double LowerTempLimit = 15;
|
|
const Double TempDeviationLimit = (Double)0.5;
|
|
|
|
try
|
|
{
|
|
//todo add form roland
|
|
//var currentUsage = new LastUsage() { Password = Password, RequestPortType = TransferMode, RequestPortName = SerialPortCmdChannel, StreamingPortName = lB_Comport_DataInterface.SelectedItem.ToString() };
|
|
|
|
//var text = JsonConvert.SerializeObject(currentUsage);
|
|
//File.WriteAllText("lastUsage.json", text);
|
|
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
|
|
}
|
|
|
|
|
|
try
|
|
{
|
|
TempCal_Start(Password, TransferMode, SerialPortCmdChannel, UpperTempLimit, LowerTempLimit, TempDeviationLimit, Culture);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
GlobalMeterBatch?.RemoveAllMeters();
|
|
DisplayTempCal.DebugMessage($"Exception:\t\t{ex.Message} \n", Culture);
|
|
}
|
|
finally
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
|
|
private DateTime? lastUpdate0;
|
|
private DateTime? lastUpdate1;
|
|
private DateTime? lastUpdate2;
|
|
|
|
|
|
private void frmTempCal_OnZeroFlowRecordIsDecoded(object sender, CalibrationRecordWithMeterNumber decodedDataAndMeterNr)
|
|
{
|
|
CultureInfo Culture = frmTempCalibration._frmTempCalibration.GetGlobalCulture();
|
|
#region Definitions and initializations
|
|
var decodedDate = decodedDataAndMeterNr;
|
|
var MeterNumber = decodedDataAndMeterNr.MeterNumber;
|
|
var data = ((CalibrationRecord)decodedDate.CalibChl);
|
|
//todo make new imesturementrecord according to units need by zeroflow app
|
|
data.TotalTimeOfFlightS = data.TotalTimeOfFlightS * 1000000;
|
|
Double temp = data.DeltaTimeOfFlightS;
|
|
//data.DeltaTimeOfFlightS = data.DeltaTimeOfFlightS * (1.0 / 0x4000000000); // 2^38;
|
|
data.AmplitudeUpV = data.AmplitudeUpV * 1000.0;
|
|
data.AmplitudeDownV = data.AmplitudeDownV * 1000.0;
|
|
|
|
//todo check performance -> into ram
|
|
#endregion
|
|
#region Add to list h-protocol
|
|
UInt16 Path = (UInt16)(decodedDate.CalibChl.Channel - 1);
|
|
//todo check if isValid == crc Ok
|
|
if (decodedDate.CalibChl.IsValid)
|
|
{
|
|
#region Activity check for empty pipe test
|
|
LineCounterEmptyPipeTest[Path] = Counters.SetCountersTempCal(EnableIndicatorEmptyPipeTest, Path, LineCounterEmptyPipeTest);
|
|
#endregion
|
|
#region Activity check for temperature pipe test
|
|
LineCounterTemperatureTest[Path] = Counters.SetCountersTempCal(EnableIndicatorTempTest, Path, LineCounterTemperatureTest);
|
|
#endregion
|
|
}
|
|
#endregion
|
|
#region Copy to global object
|
|
|
|
|
|
DecodedAllMeters[Path] = ((CalibrationRecord)decodedDate.CalibChl.Clone());
|
|
|
|
if (frmTempCalibration._frmTempCalibration.GetLoggingIndicatorTempTest())
|
|
{
|
|
try
|
|
{
|
|
String time = DateTime.Now.ToString(Formats.RawDataDateTimeLogString, Culture);
|
|
// SetDataToLog($"{GetDataToLog()} {time} {decodedDate.RawData}\n");
|
|
SetDataToLog($"{GetDataToLog()} {time} {Path.ToString(Culture)} {Math.Round(DecodedAllMeters[Path].TemperatureDegC, 4).ToString(Culture)}\n");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
private void frmTempCalibration_Load(object sender, EventArgs e)
|
|
{
|
|
rB_Adjustment.Checked = true;
|
|
String[] ListOfComPorts = SerialPort.GetPortNames();
|
|
for (UInt16 i = 0; i < ListOfComPorts.Count(); i++)
|
|
{
|
|
lB_Comport_CmdInterface.Items.Add(ListOfComPorts[i]);
|
|
lB_Comport_DataInterface.Items.Add(ListOfComPorts[i]);
|
|
}
|
|
|
|
if (!File.Exists("lastUsage.json")) return;
|
|
|
|
try
|
|
{
|
|
using (var tr = new StreamReader("lastUsage.json"))
|
|
{
|
|
//todo add from roland
|
|
//var _fileString = tr.ReadToEnd();
|
|
//var lastConfig = JsonConvert.DeserializeObject<LastUsage>(_fileString);
|
|
//lB_Comport_CmdInterface.SelectedItem = lastConfig.RequestPortName;
|
|
//lB_Comport_DataInterface.SelectedItem = lastConfig.StreamingPortName;
|
|
//lBTransferMode.SelectedItem = lastConfig.RequestPortType;
|
|
//tBPassword.Text = lastConfig.Password;
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
private void btn_refresh_Click(object sender, EventArgs e)
|
|
{
|
|
lB_Comport_CmdInterface.Items.Clear();
|
|
lB_Comport_DataInterface.Items.Clear();
|
|
String[] ListOfComPorts = SerialPort.GetPortNames();
|
|
for (UInt16 i = 0; i < ListOfComPorts.Count(); i++)
|
|
{
|
|
lB_Comport_CmdInterface.Items.Add(ListOfComPorts[i]);
|
|
lB_Comport_DataInterface.Items.Add(ListOfComPorts[i]);
|
|
}
|
|
}
|
|
|
|
//private void btnAutoDetect_Click(object sender, EventArgs e)
|
|
//{
|
|
// CultureInfo Culture = GetGlobalCulture();
|
|
// String Password = GetPassword();
|
|
|
|
// DisplayTempCal.DebugMessage("APPLICATION:\t\t AUTODETECT started\n", Culture);
|
|
// DisplayTempCal.StatusLabel("Wait until AUTODETECT has finished");
|
|
// DisplayTempCal.SetProgressPanel(StatusPanelItems.Detect);
|
|
// Misc.WaitNSeconds(1, true);
|
|
|
|
// Boolean PasswordOK = false;
|
|
|
|
// PasswordOK = Misc.OnlyHexInString(Password) && (Int16.Equals((Int16)Password.Count(), (Int16)12));
|
|
|
|
|
|
// if (PasswordOK)
|
|
// {
|
|
// try
|
|
// {
|
|
// gB_Setup.Enabled = false;
|
|
// btn_TempCal_Detect.Enabled = false;
|
|
// gB_Mode.Enabled = false;
|
|
// gB_SetTemperature.Enabled = false;
|
|
// btn_Save.Enabled = false;
|
|
// btn_Clear.Enabled = false;
|
|
|
|
// var allPorts = SerialPort.GetPortNames();
|
|
// if (allPorts.Length < 2)
|
|
// {
|
|
// throw new ApplicationException("No COMPORTS found");
|
|
// }
|
|
// List<String> useAblePorts = new List<String>();
|
|
// foreach (var portname in allPorts)
|
|
// {
|
|
|
|
// DisplayTempCal.DebugMessage($"APPLICATION:\t\t Check port {portname}\n", Culture);
|
|
// Misc.WaitNMilliseconds(100);
|
|
|
|
// try
|
|
// {
|
|
// using (var sp = new SerialPort(portname))
|
|
// {
|
|
// sp.Open();
|
|
// sp.Close();
|
|
// useAblePorts.Add(portname);
|
|
|
|
// DisplayTempCal.DebugMessage($"APPLICATION:\t\t {portname} OK\n", Culture);
|
|
// Misc.WaitNMilliseconds(100);
|
|
// }
|
|
// }
|
|
// catch (Exception)
|
|
// {
|
|
|
|
// }
|
|
// }
|
|
// //useAblePorts.Add("COM1");
|
|
// //useAblePorts.Add("COM2");
|
|
// //useAblePorts.Add("COM3");
|
|
// //useAblePorts.Add("COM94");
|
|
|
|
|
|
// useAblePorts.Add("COM107");
|
|
// useAblePorts.Add("COM108");
|
|
// //useAblePorts.Add("COM109");
|
|
// //useAblePorts.Add("COM110");
|
|
|
|
// int hitCount = 0;
|
|
// PortConfig hitRequestPort;
|
|
// foreach (var PortName in useAblePorts)
|
|
// {
|
|
|
|
// try
|
|
// {
|
|
// var altPort = hitCount + 1;
|
|
// if (altPort >= allPorts.Length)
|
|
// {
|
|
// altPort = 0;
|
|
// }
|
|
|
|
// var tmpPortRequest = new PortConfig() { BaudRaterialPort) };
|
|
|
|
|
|
// using (var tmpMeter = new GenesisMeter(0, tmpPortRequest, null, false))
|
|
// {
|
|
// using (var mb = new MeterBatch())
|
|
// {
|
|
// mb.AddMeter(tmpMeter);
|
|
// DisplayTempCal.DebugMessage($"APPLICATION:\t\t Try to login at {PortName}\n", Culture);
|
|
// Misc.WaitNMilliseconds(300);
|
|
// if (tmpMeter.Login(Password))
|
|
// {
|
|
// //hit
|
|
// //tmpMeter.WriteRegister(Register.Genesisflow.TriggerActive, new byte[] { 0, 0, 0, 0 }, true);
|
|
// tmpMeter.WriteRegister(Register.Genesisflow.SampleRate, new byte[] { 1, 0, 0, 0 }, true);
|
|
// tmpMeter.WriteRegisterSafe(Register.Genesisflow.LedMode,
|
|
// LedMode.FlowTestAndCalibData.GetHashCode());
|
|
// hitRequestPort = tmpPortRequest;
|
|
// mb.RemoveAllMeters();
|
|
// //MessageBox.Show($"Find Comport {tmpPortRequest.SerialPort.PortName} as Request");
|
|
// break;
|
|
|
|
// }
|
|
// else
|
|
// {
|
|
// mb.RemoveAllMeters();
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
|
|
// }
|
|
// catch (Exception)
|
|
// {
|
|
|
|
// }
|
|
// hitCount = hitCount + 1;
|
|
// }
|
|
|
|
// var hitStreamingPort = "";
|
|
// if (hitRequestPort != null)
|
|
// {
|
|
// foreach (var streaming in useAblePorts)
|
|
// {
|
|
// try
|
|
// {
|
|
// if (hitRequestPort.SerialPort.PortName != streaming)
|
|
// {
|
|
// using (var tmpSerialPort = new SerialPort(streaming, 115200))
|
|
// {
|
|
// tmpSerialPort.ReadTimeout = 1000;
|
|
// tmpSerialPort.Open();
|
|
// var result = tmpSerialPort.ReadLine();
|
|
// if (result.Contains("@"))
|
|
// {
|
|
// hitStreamingPort = streaming;
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// catch (Exception exception)
|
|
// {
|
|
// Console.WriteLine(exception);
|
|
// }
|
|
// }
|
|
// }
|
|
// if (hitRequestPort == null)
|
|
// {
|
|
// DisplayTempCal.SetProgressPanel(StatusPanelItems.None);
|
|
// MessageBox.Show("No request port found", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
// }
|
|
// else
|
|
// {
|
|
// DisplayTempCal.DebugMessage("COMMAND CHANNEL:\t Request port found\n", Culture);
|
|
// MessageBox.Show("Request port found", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
// lB_Comport_CmdInterface.SetSelected(lB_Comport_CmdInterface.Items.IndexOf(hitRequestPort.SerialPort.PortName), true);
|
|
// if (String.IsNullOrEmpty(hitStreamingPort))
|
|
// {
|
|
// DisplayTempCal.SetProgressPanel(StatusPanelItems.None);
|
|
// MessageBox.Show("No streaming port found", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
// }
|
|
// else
|
|
// {
|
|
// lB_Comport_DataInterface.SetSelected(lB_Comport_DataInterface.Items.IndexOf(hitStreamingPort), true);
|
|
// DisplayTempCal.DebugMessage("DATA CHANNEL:\t\t Streaming port found\n", Culture);
|
|
// MessageBox.Show("Streaming port found", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
// }
|
|
// }
|
|
// }
|
|
// catch
|
|
// {
|
|
// DisplayTempCal.DebugMessage("APPLICATION:\t\t AUTODETECT failed!\n", Culture);
|
|
// }
|
|
|
|
// gB_Mode.Enabled = true;
|
|
// gB_Setup.Enabled = true;
|
|
// btn_TempCal_Detect.Enabled = true;
|
|
// gB_SetTemperature.Enabled = true;
|
|
// btn_Save.Enabled = true;
|
|
// btn_Clear.Enabled = true;
|
|
|
|
// DisplayTempCal.DebugMessage("APPLICATION:\t\t AUTODETECT done\n", Culture);
|
|
// DisplayTempCal.StatusLabel("AUTODETECT has finished, Press 'PREPARE'");
|
|
// }
|
|
// else
|
|
// {
|
|
// DisplayTempCal.DebugMessage("APPLICATION:\t\t Password invalid\n", Culture);
|
|
// MessageBox.Show("Password invalid", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
// }
|
|
|
|
|
|
|
|
//}
|
|
|
|
private void btn_Clear_Click(object sender, EventArgs e)
|
|
{
|
|
rTB_TempCal.Clear();
|
|
}
|
|
|
|
private void btn_Save_Click(object sender, EventArgs e)
|
|
{
|
|
#region Definitions and initializations
|
|
CultureInfo Culture = GetGlobalCulture();
|
|
String SaveDataPathRaw = String.Empty;
|
|
Boolean RawDialogOk = false;
|
|
String Username = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
|
|
String ClosingPath = DataLogging.DefaultPath;// + "GenesisZeroFlow_EventLogging_" + TimeForFilename + ".txt";
|
|
String TimeForHeader = String.Empty;
|
|
#endregion
|
|
#region Logfile
|
|
try
|
|
{
|
|
RawDialogOk = Files.SaveFiledialogTempCalTxt(out SaveDataPathRaw, ClosingPath, PcbId, out TimeForHeader, Culture);
|
|
if (RawDialogOk)
|
|
{
|
|
String SwVersion = this.Text.Replace("SENSUS Hannover - Temperature Calibrator ", String.Empty);
|
|
String Data = rTB_TempCal.Text;
|
|
String Header = $"Filename = {Path.GetFileName(SaveDataPathRaw)}; User = {Username}; Date/Time = {TimeForHeader}; PcbID: {PcbId}; SW-Version {SwVersion}\n";
|
|
Task.Run(() =>
|
|
{
|
|
Logging.WriteToFile($"{Header}{Data}", SaveDataPathRaw);
|
|
});
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
ErrorLog.Log(LogErrReason.Exeption, "btn_Save_Click() failed", $"0x{ex.HResult.ToString("X", Culture)}", String.Empty, Culture);
|
|
MessageBox.Show("Log file storage failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
private void frmTempCalibration_FormClosing(object sender, FormClosingEventArgs e)
|
|
{
|
|
GlobalMeterBatch.Dispose();
|
|
Environment.Exit(0);
|
|
}
|
|
|
|
|
|
}
|
|
}
|