641 lines
20 KiB
C#
641 lines
20 KiB
C#
using CordonelPreadjustmentUi;
|
|
using Logic.ProductionToProductMapper.Cordonel;
|
|
using Newtonsoft.Json;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Linq;
|
|
using System.Runtime.InteropServices;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
|
|
using Xylem.Common.Logic.ProductionOrderCore.OrderData;
|
|
using Xylem.Common.Logic.SoftwareAccessHelper;
|
|
using XylemCommonUiLegacyGenCtl.DataPackage;
|
|
using XylemCommonUiLegacyGenCtl.Enums;
|
|
using static Xylem.Common.Ui.CordonelPreadjustmentUi.MeterStateControl;
|
|
|
|
namespace XylemCommonUiLegacyGenCtl
|
|
{
|
|
[Guid("4F5EA77A-AAAA-4909-9419-B8ED1B63BA28"),
|
|
ComVisible(true),
|
|
ClassInterface(ClassInterfaceType.None),
|
|
ComSourceInterfaces(typeof(ITestBenchEvents))]
|
|
|
|
public partial class ctlBenchRdy : UserControl, ICtlTestBench, IDisposable
|
|
{
|
|
private Dictionary<int, ctlMeterReady> MeterControls;
|
|
private MeterBatch meterBatch;
|
|
|
|
public delegate void OnUserInputDoneDelegate();
|
|
private event OnUserInputDoneDelegate OnUserInputDone;
|
|
|
|
private int testBenchId { get; set; }
|
|
private int userId { get; set; }
|
|
|
|
private DefaultSettings SettingsToUse;
|
|
|
|
public ctlBenchRdy()
|
|
{
|
|
InitializeComponent();
|
|
|
|
}
|
|
|
|
private void ctlMeterReady1_Load(object sender, EventArgs e)
|
|
{
|
|
|
|
}
|
|
|
|
public void Init(int v, int TestBenchId, int UserId, bool Research)
|
|
{
|
|
testBenchId = TestBenchId;
|
|
userId = UserId;
|
|
meterBatch = new MeterBatch();
|
|
MeterControls = new Dictionary<int, ctlMeterReady>();
|
|
MeterControls.Add(1, ctlMeterReady1);
|
|
MeterControls.Add(2, ctlMeterReady2);
|
|
MeterControls.Add(3, ctlMeterReady3);
|
|
MeterControls.Add(4, ctlMeterReady4);
|
|
MeterControls.Add(5, ctlMeterReady5);
|
|
MeterControls.Add(6, ctlMeterReady6);
|
|
MeterControls.Add(7, ctlMeterReady7);
|
|
MeterControls.Add(8, ctlMeterReady8);
|
|
MeterControls.Add(9, ctlMeterReady9);
|
|
MeterControls.Add(10, ctlMeterReady10);
|
|
foreach (var item in MeterControls)
|
|
{
|
|
item.Value.SetSlot(item.Key, meterBatch);
|
|
|
|
item.Value.Enabled = false;
|
|
item.Value.Visible = false;
|
|
}
|
|
for (int i = 1; i <= v; i++)
|
|
{
|
|
MeterControls[i].Enabled = true;
|
|
MeterControls[i].Visible = true;
|
|
MeterControls[i].OnStateChanged += ctlCheckTestBenchReady_Load;
|
|
}
|
|
|
|
var settings = new DefaultSettings();
|
|
if (TestBenchId == 2016)
|
|
{
|
|
settings.Adjustment = DefaultSettings.DetectedMeterEnum.Always;
|
|
settings.FlowAdjustmentTarget = 0.35M;
|
|
settings.FlowTesting = DefaultSettings.DetectedMeterEnum.Always;
|
|
settings.PreAdjustment = DefaultSettings.DetectedMeterEnum.Always;
|
|
settings.Temp = TempSouceType.TempFlansh;
|
|
settings.Delay = 10;
|
|
settings.Research = false;
|
|
|
|
}
|
|
Usedefault(settings);
|
|
|
|
|
|
}
|
|
|
|
|
|
private void button1_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
}
|
|
|
|
private void ctlCheckTestBenchReady_Load(object sender, EventArgs e)
|
|
{
|
|
|
|
}
|
|
|
|
public new void Dispose()
|
|
{
|
|
base.Dispose();
|
|
|
|
}
|
|
|
|
private void lblDoPreajdus_Click(object sender, EventArgs e)
|
|
{
|
|
cbxDoPreajdustment.Checked = !cbxDoPreajdustment.Checked;
|
|
}
|
|
|
|
private void duFlowCalibration_Click(object sender, EventArgs e)
|
|
{
|
|
cbDoFlowCalibration.Checked = !cbDoFlowCalibration.Checked;
|
|
}
|
|
|
|
private void cbDoFlowCalibration_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if (cbDoFlowCalibration.Checked)
|
|
{
|
|
cbDoFlowCalibration.Text = "V";
|
|
}
|
|
else
|
|
{
|
|
cbDoFlowCalibration.Text = "-";
|
|
}
|
|
foreach (var item in MeterControls)
|
|
{
|
|
if (item.Value.Enabled && item.Value.PcbId != "-" && item.Value.PcbId != "")
|
|
{
|
|
item.Value.SetFlowCalibration(cbDoFlowCalibration.Checked);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private void cbxDoPreajdustment_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if (cbxDoPreajdustment.Checked)
|
|
{
|
|
cbxDoPreajdustment.Text = "V";
|
|
}
|
|
else
|
|
{
|
|
cbxDoPreajdustment.Text = "-";
|
|
}
|
|
foreach (var item in MeterControls)
|
|
{
|
|
if (item.Value.Enabled && item.Value.PcbId != "-" && item.Value.PcbId != "")
|
|
{
|
|
item.Value.SetPreadjustmentValue(cbxDoPreajdustment.Checked);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private void nudCalibrationTarget_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
foreach (var item in MeterControls)
|
|
{
|
|
if (item.Value.Enabled && item.Value.PcbId != "-" && item.Value.PcbId != "")
|
|
{
|
|
item.Value.SetCalibrationTarget(nudCalibrationTarget.Value);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private void btnTemp11_Click(object sender, EventArgs e)
|
|
{
|
|
CheckTempFlansh(btnTemp11, lblTempTF11, 11);
|
|
}
|
|
|
|
private void CheckTempFlansh(Button btnTemp, Label lblTempTF, int Slot)
|
|
{
|
|
if (btnTemp.Text == "A")
|
|
{
|
|
var tempText = "...";
|
|
lblTempTF.Text = tempText;
|
|
btnTemp.Text = "W";
|
|
var t = new Task(() =>
|
|
{
|
|
|
|
try
|
|
{
|
|
var temp = GetTempCalcToF(Slot);
|
|
if (temp.HasValue)
|
|
{
|
|
tempText = $"{ temp.Value.ToString("N3") } °C";
|
|
}
|
|
else
|
|
{
|
|
tempText = "NA!";
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
tempText = "Error!";
|
|
}
|
|
|
|
});
|
|
t.Start();
|
|
|
|
t.ContinueWith((r) =>
|
|
{
|
|
|
|
Invoke(new Action(() =>
|
|
{
|
|
lblTempTF.Text = tempText;
|
|
btnTemp.Text = "A";
|
|
}));
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
private void btnTemp12_Click(object sender, EventArgs e)
|
|
{
|
|
CheckTempFlansh(btnTemp12, lblTempTF12, 12);
|
|
|
|
}
|
|
|
|
|
|
private decimal? GetTempCalcToF(int slot)
|
|
{
|
|
try
|
|
{
|
|
using (var ThermoMeterBatch = new MeterBatch())
|
|
{
|
|
using (var currentMeter = new ZeroFlowGenesisMeter(slot, 3, false))
|
|
{
|
|
currentMeter.LogOnEnable = true;
|
|
currentMeter.LoginFailed = false;
|
|
currentMeter.PreparationFailed = false;
|
|
currentMeter.AmplitudeFailed = false;
|
|
currentMeter.ZeroFlowOffsetFailed = false;
|
|
currentMeter.AmplitudeFailed = false;
|
|
currentMeter.CompletionFailed = false;
|
|
currentMeter.Ok = false;
|
|
currentMeter.EmptyPipeCheckEnable = false;
|
|
currentMeter.EmptyPipeCheckFailed = false;
|
|
|
|
ThermoMeterBatch.AddMeter(currentMeter);
|
|
|
|
|
|
|
|
currentMeter.CheckStreamingPort();
|
|
|
|
|
|
currentMeter.StartRecordData();
|
|
currentMeter.LogRawData(true);
|
|
|
|
|
|
|
|
List<Tuple<double, double>> TempFromTofLUT;
|
|
|
|
currentMeter.WriteLog($"StartTempWatch on ctlCheckTestBenchReady");
|
|
|
|
currentMeter.logAmpTest = true;
|
|
|
|
TempFromTofLUT = new List<Tuple<double, double>>();
|
|
|
|
var pcbid = "notFound";
|
|
try
|
|
{
|
|
pcbid = currentMeter.GetPcbId();
|
|
if (string.IsNullOrEmpty(pcbid))
|
|
{
|
|
pcbid = currentMeter.GetPcbId();
|
|
}
|
|
|
|
|
|
|
|
var resp = LocalWebRequest.GetRequest($"http://10.49.40.25/MeterProcessState/api/TempFlange/GetLut?PcbId={pcbid}", 10000);
|
|
var cordonelTempLut = JsonConvert.DeserializeObject<List<CordonelTempLut>>(resp);
|
|
TempFromTofLUT = new List<Tuple<double, double>>();
|
|
|
|
foreach (var item in cordonelTempLut.OrderBy(a => a.RefTempC))
|
|
{
|
|
TempFromTofLUT.Add(new Tuple<double, double>(item.AvgTof, item.RefTempC));
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
currentMeter.WriteLog($"StartTempWatch with LUT faild for meter {pcbid} with ex{ex.Message}");
|
|
|
|
}
|
|
var till = DateTime.Now.AddSeconds(30);
|
|
while (currentMeter.CurrentRecords.Count < 250 && DateTime.Now < till)
|
|
{
|
|
Thread.Sleep(50);
|
|
}
|
|
|
|
|
|
var cRecords = currentMeter.CurrentRecords.ToList();
|
|
currentMeter.WriteLog($"cRecords.Count={cRecords.Count}");
|
|
if (cRecords != null && cRecords.Any())
|
|
{
|
|
decimal checkTempMeter = 0;
|
|
|
|
//
|
|
|
|
var sumTof = 0.0;
|
|
var countTof = 0;
|
|
foreach (var tofItem in cRecords.Where(c => c.Channel == 2))
|
|
{
|
|
|
|
|
|
if (tofItem.Channel == 2)
|
|
{
|
|
Log($"TotalTimeOfFlightS;{(tofItem.TotalTimeOfFlightS * 1000).ToString()}");
|
|
Log($"RAWTEMP;{interPol(TempFromTofLUT, (tofItem.TotalTimeOfFlightS * 1000))}");
|
|
sumTof = (tofItem.TotalTimeOfFlightS * 1000) + sumTof;
|
|
countTof = countTof + 1;
|
|
}
|
|
|
|
}
|
|
|
|
var x = (sumTof / countTof) / 1000;
|
|
|
|
|
|
Log($"avgTof;{x}({sumTof}/{countTof})");
|
|
return interPol(TempFromTofLUT, x);
|
|
|
|
}
|
|
else
|
|
{
|
|
Log($"temp NA");
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log($"temp NA - {ex.Message}");
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void Log(string v)
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
private static decimal interPol(List<Tuple<double, double>> points, double x)
|
|
{
|
|
var x1 = 0.000;
|
|
var y1 = 0.000;
|
|
var x2 = 0.000;
|
|
var y2 = 0.000;
|
|
decimal checkTempMeter;
|
|
if ((x <= points[0].Item1) && (x >= points.Last().Item1))
|
|
{
|
|
var i = 0;
|
|
foreach (var val in points)
|
|
{
|
|
if (points[i].Item1 <= x)
|
|
{
|
|
x1 = points[i - 1].Item1;
|
|
y1 = points[i - 1].Item2;
|
|
x2 = points[i].Item1;
|
|
y2 = points[i].Item2;
|
|
break;
|
|
}
|
|
i = i + 1;
|
|
}
|
|
|
|
checkTempMeter = (decimal)((y2 - y1) / (x2 - x1) * (x - x1) + y1);
|
|
}
|
|
else
|
|
{
|
|
checkTempMeter = 1;
|
|
}
|
|
|
|
return checkTempMeter;
|
|
}
|
|
|
|
private CancellationTokenSource OverallCancellationTokenSource = new CancellationTokenSource();
|
|
private void button4_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
|
|
|
|
foreach (var item in MeterControls)
|
|
{
|
|
if (item.Value.Enabled)
|
|
{
|
|
item.Value.Start(OverallCancellationTokenSource.Token, false, SettingsToUse);
|
|
}
|
|
|
|
}
|
|
}
|
|
public TestSetupContainer testControler = new TestSetupContainer();
|
|
private void btnTake_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
Take(false);
|
|
|
|
}
|
|
|
|
private void Take(bool start = false)
|
|
{
|
|
OverallCancellationTokenSource.Cancel();
|
|
testControler = new TestSetupContainer();
|
|
if (rbtTempManualInput.Checked)
|
|
{
|
|
testControler.TempSouce = Enums.TempSouceType.ManualInput;
|
|
}
|
|
else if (rbtTempPtOverSps.Checked)
|
|
{
|
|
testControler.TempSouce = Enums.TempSouceType.PtOverSps;
|
|
}
|
|
else if (rbtTempFlansh.Checked)
|
|
{
|
|
testControler.TempSouce = Enums.TempSouceType.TempFlansh;
|
|
}
|
|
else
|
|
{
|
|
//ahhhhhhhhhhhhhhhhh
|
|
testControler.TempSouce = Enums.TempSouceType.ManualInput;
|
|
}
|
|
testControler.ProductionMode = !cbxResearch.Checked;
|
|
|
|
|
|
testControler.AllChanelsRequired = cbxAllChannlesReq.Checked;
|
|
|
|
testControler.DelayInSBeforStart = (int)nudDelay.Value;
|
|
|
|
//testControler.MeterSize
|
|
MeterSize biggestMeterSize = MeterSize.DN40;
|
|
testControler.meterTestSettings = new MeterTestSettings[MeterControls.Count];
|
|
foreach (var item in MeterControls)
|
|
{
|
|
if (item.Value.Enabled)
|
|
{
|
|
if (item.Value.Metersize != MeterSize.NA && biggestMeterSize < item.Value.Metersize)
|
|
{
|
|
biggestMeterSize = item.Value.Metersize;
|
|
}
|
|
testControler.meterTestSettings[item.Key - 1] = item.Value.GetMeterTestSettings();
|
|
}
|
|
}
|
|
testControler.MeterSize = biggestMeterSize;
|
|
OnUserInputDone?.Invoke();
|
|
testControler.WatingForDecision = false;
|
|
}
|
|
|
|
private void button2_Click(object sender, EventArgs e)
|
|
{
|
|
testControler = new TestSetupContainer();
|
|
testControler.WatingForDecision = false;
|
|
OverallCancellationTokenSource.Cancel();
|
|
}
|
|
|
|
private void btnRun_Click(object sender, EventArgs e)
|
|
{
|
|
Take(true);
|
|
}
|
|
|
|
public dynamic GetContainer()
|
|
{
|
|
return testControler;
|
|
}
|
|
|
|
public void Kill()
|
|
{
|
|
Dispose();
|
|
}
|
|
|
|
public bool GetWatingForDecision()
|
|
{
|
|
return testControler.WatingForDecision;
|
|
}
|
|
|
|
public bool GetDirectStart()
|
|
{
|
|
return testControler.WatingForDecision;
|
|
}
|
|
|
|
public TempSouceType GetTempSouce()
|
|
{
|
|
return testControler.TempSouce;
|
|
}
|
|
|
|
public int GetMeterSize()
|
|
{
|
|
return (int)testControler.MeterSize;
|
|
}
|
|
public int GetDelayInSBeforStart()
|
|
{
|
|
return testControler.DelayInSBeforStart;
|
|
}
|
|
|
|
public bool GetAllChanelsRequired()
|
|
{
|
|
return testControler.AllChanelsRequired;
|
|
}
|
|
|
|
public bool GetProductionMode()
|
|
{
|
|
return testControler.ProductionMode;
|
|
}
|
|
|
|
public bool GetSlotPresent(int slot)
|
|
{
|
|
var a = testControler.meterTestSettings?.First(w => w.Slot == slot);
|
|
|
|
return a != null && !string.IsNullOrEmpty(a.SerialNr) && a.SerialNr != "-" && (a.FlowTesting || a.PreAdjustment || a.FlowAdjustment);
|
|
}
|
|
|
|
public string GetSlotSerialNr(int slot)
|
|
{
|
|
return testControler.meterTestSettings?.First(w => w.Slot == slot)?.SerialNr;
|
|
}
|
|
|
|
public bool GetSlotFlowAdjustment(int slot)
|
|
{
|
|
var a = testControler.meterTestSettings?.First(w => w.Slot == slot)?.FlowAdjustment;
|
|
return (a ?? false);
|
|
}
|
|
|
|
public decimal GetFlowAdjustmentTarget(int slot)
|
|
{
|
|
return (testControler.meterTestSettings?.First(w => w.Slot == slot)?.FlowAdjustmentTarget ?? 0);
|
|
}
|
|
|
|
public bool GetPreAdjustment(int slot)
|
|
{
|
|
var a = testControler.meterTestSettings?.First(w => w.Slot == slot)?.PreAdjustment;
|
|
return (a ?? false);
|
|
}
|
|
|
|
|
|
public bool GetFlowTesting(int slot)
|
|
{
|
|
var a = testControler.meterTestSettings?.First(w => w.Slot == slot)?.FlowTesting;
|
|
return (a ?? false);
|
|
}
|
|
|
|
public bool GetSlotFlowAdjustmentAny()
|
|
{
|
|
var a = testControler.meterTestSettings?.Any(w => w != null && w.FlowAdjustment);
|
|
return (a ?? false);
|
|
}
|
|
|
|
public bool GetPreAdjustmentAny()
|
|
{
|
|
var a = testControler.meterTestSettings?.Any(w => w != null && w.PreAdjustment);
|
|
return (a ?? false);
|
|
}
|
|
|
|
public bool GetSlotFlowTestingAny()
|
|
{
|
|
var a = testControler.meterTestSettings?.Any(w => w != null && w.FlowTesting);
|
|
return (a ?? false);
|
|
}
|
|
private void btnStationDefault_Click(object sender, EventArgs e)
|
|
{
|
|
Usedefault(new DefaultSettings());
|
|
}
|
|
|
|
private void Usedefault(DefaultSettings setting)
|
|
{
|
|
cbxAllChannlesReq.Checked = setting.AllChnlsReq;
|
|
nudDelay.Value = setting.Delay;
|
|
nudCalibrationTarget.Value = setting.FlowAdjustmentTarget;
|
|
|
|
cbxResearch.Checked = setting.Research;
|
|
switch (setting.Temp)
|
|
{
|
|
case TempSouceType.ManualInput:
|
|
rbtTempManualInput.Checked = true;
|
|
break;
|
|
case TempSouceType.PtOverSps:
|
|
rbtTempPtOverSps.Checked = true;
|
|
break;
|
|
case TempSouceType.TempFlansh:
|
|
break;
|
|
default:
|
|
rbtTempManualInput.Checked = true;
|
|
break;
|
|
}
|
|
|
|
switch (setting.mode)
|
|
{
|
|
case DefaultSettings.ViewMode.Easy:
|
|
trackBar1.Value = 0;
|
|
break;
|
|
case DefaultSettings.ViewMode.Mid:
|
|
trackBar1.Value = 1;
|
|
break;
|
|
case DefaultSettings.ViewMode.Expert:
|
|
trackBar1.Value = 2;
|
|
break;
|
|
default:
|
|
trackBar1.Value = 2;
|
|
break;
|
|
}
|
|
|
|
|
|
SettingsToUse = setting;
|
|
|
|
|
|
}
|
|
|
|
private void ctlMeterReady2_Load(object sender, EventArgs e)
|
|
{
|
|
|
|
}
|
|
|
|
private void ctlMeterReady2_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
}
|
|
|
|
private void trackBar1_Scroll(object sender, EventArgs e)
|
|
{
|
|
|
|
}
|
|
|
|
private void btnUserDefault_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|