1140 lines
47 KiB
C#
1140 lines
47 KiB
C#
using Logic.ProductionToProductMapper.Cordonel;
|
|
using Newtonsoft.Json;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.IO.Ports;
|
|
using System.Linq;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Xylem.Common.CommonCore.Configuration;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisCore;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisFile;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.Registers;
|
|
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
|
|
using Xylem.Common.Logic.SoftwareAccessHelper;
|
|
using static Ui.ProductionControls.ctlPictureProgressBar;
|
|
|
|
namespace CordonelAssemblyLine.Model
|
|
{
|
|
internal class PickingViewModel : INotifyPropertyChanged
|
|
{
|
|
|
|
private string state = "Warte auf Scanner";
|
|
private string scanner = "keine Verbindung";
|
|
private string slot = "-";
|
|
private string result = "-";
|
|
|
|
private System.Windows.Media.Brush resultColor;
|
|
public System.Windows.Media.Brush ResultColor
|
|
{
|
|
get
|
|
{
|
|
return resultColor;
|
|
}
|
|
set
|
|
{
|
|
resultColor = value;
|
|
NotifyPropertyChanged(nameof(ResultColor));
|
|
}
|
|
}
|
|
public string State
|
|
{
|
|
get
|
|
{
|
|
return state;
|
|
}
|
|
set
|
|
{
|
|
state = value;
|
|
NotifyPropertyChanged(nameof(State));
|
|
}
|
|
}
|
|
public string Scanner
|
|
{
|
|
get
|
|
{
|
|
return scanner;
|
|
}
|
|
set
|
|
{
|
|
scanner = value;
|
|
NotifyPropertyChanged(nameof(Scanner));
|
|
}
|
|
}
|
|
|
|
public void UpdateLogText(string text, bool forceGuiUpdate = true)
|
|
{
|
|
logText = $"{text}{Environment.NewLine}{logText}";
|
|
if (logText.Length > 2503)
|
|
{
|
|
logText = $"{logText.Substring(0, 2500)}...";
|
|
}
|
|
if (forceGuiUpdate)
|
|
{
|
|
LogText = logText;
|
|
}
|
|
|
|
}
|
|
|
|
private string historyText = "-";
|
|
public string HistoryText
|
|
{
|
|
get
|
|
{
|
|
return historyText;
|
|
}
|
|
set
|
|
{
|
|
historyText = value;
|
|
NotifyPropertyChanged(nameof(HistoryText));
|
|
}
|
|
}
|
|
|
|
private string logText = "Start";
|
|
public string LogText
|
|
{
|
|
get
|
|
{
|
|
return logText;
|
|
}
|
|
set
|
|
{
|
|
logText = value;
|
|
NotifyPropertyChanged(nameof(LogText));
|
|
}
|
|
}
|
|
|
|
public string Slot
|
|
{
|
|
get
|
|
{
|
|
return slot;
|
|
}
|
|
set
|
|
{
|
|
slot = value;
|
|
NotifyPropertyChanged(nameof(Slot));
|
|
}
|
|
}
|
|
public string Result
|
|
{
|
|
get
|
|
{
|
|
return result;
|
|
}
|
|
set
|
|
{
|
|
result = value;
|
|
NotifyPropertyChanged(nameof(Result));
|
|
}
|
|
}
|
|
|
|
private string pLblS01Text;
|
|
public string lblS01Text { get { return pLblS01Text; } set { pLblS01Text = value; NotifyPropertyChanged(nameof(lblS01Text)); } }
|
|
|
|
private string pLblS02Text;
|
|
public string lblS02Text { get { return pLblS02Text; } set { pLblS02Text = value; NotifyPropertyChanged(nameof(lblS02Text)); } }
|
|
|
|
private string pLblS03Text;
|
|
public string lblS03Text { get { return pLblS03Text; } set { pLblS03Text = value; NotifyPropertyChanged(nameof(lblS03Text)); } }
|
|
|
|
private string pLblS04Text;
|
|
public string lblS04Text { get { return pLblS04Text; } set { pLblS04Text = value; NotifyPropertyChanged(nameof(lblS04Text)); } }
|
|
|
|
private string pLblS05Text;
|
|
public string lblS05Text { get { return pLblS05Text; } set { pLblS05Text = value; NotifyPropertyChanged(nameof(lblS05Text)); } }
|
|
|
|
private string pLblS06Text;
|
|
public string lblS06Text { get { return pLblS06Text; } set { pLblS06Text = value; NotifyPropertyChanged(nameof(lblS06Text)); } }
|
|
|
|
private string pLblS07Text;
|
|
public string lblS07Text { get { return pLblS07Text; } set { pLblS07Text = value; NotifyPropertyChanged(nameof(lblS07Text)); } }
|
|
|
|
private string pLblS08Text;
|
|
public string lblS08Text { get { return pLblS08Text; } set { pLblS08Text = value; NotifyPropertyChanged(nameof(lblS08Text)); } }
|
|
|
|
private string pLblS09Text;
|
|
public string lblS09Text { get { return pLblS09Text; } set { pLblS09Text = value; NotifyPropertyChanged(nameof(lblS09Text)); } }
|
|
|
|
private string pLblS10Text;
|
|
public string lblS10Text { get { return pLblS10Text; } set { pLblS10Text = value; NotifyPropertyChanged(nameof(lblS10Text)); } }
|
|
|
|
private string pLblS11Text;
|
|
public string lblS11Text { get { return pLblS11Text; } set { pLblS11Text = value; NotifyPropertyChanged(nameof(lblS11Text)); } }
|
|
|
|
private System.Windows.Media.Brush progressWating = (System.Windows.Media.Brush)(new System.Windows.Media.BrushConverter()).ConvertFromString("Aquamarine");
|
|
private System.Windows.Media.Brush progressCurrent = (System.Windows.Media.Brush)(new System.Windows.Media.BrushConverter()).ConvertFromString("yellow");
|
|
private System.Windows.Media.Brush progressDone = (System.Windows.Media.Brush)(new System.Windows.Media.BrushConverter()).ConvertFromString("green");
|
|
private System.Windows.Media.Brush progressError = (System.Windows.Media.Brush)(new System.Windows.Media.BrushConverter()).ConvertFromString("red");
|
|
|
|
|
|
private System.Windows.Media.Brush _lblS01Color;
|
|
public System.Windows.Media.Brush lblS01Color { get { return _lblS01Color; } set { _lblS01Color = value; NotifyPropertyChanged(nameof(lblS01Color)); } }
|
|
|
|
private System.Windows.Media.Brush _lblS02Color;
|
|
public System.Windows.Media.Brush lblS02Color { get { return _lblS02Color; } set { _lblS02Color = value; NotifyPropertyChanged(nameof(lblS02Color)); } }
|
|
|
|
private System.Windows.Media.Brush _lblS03Color;
|
|
public System.Windows.Media.Brush lblS03Color { get { return _lblS03Color; } set { _lblS03Color = value; NotifyPropertyChanged(nameof(lblS03Color)); } }
|
|
|
|
private System.Windows.Media.Brush _lblS04Color;
|
|
public System.Windows.Media.Brush lblS04Color { get { return _lblS04Color; } set { _lblS04Color = value; NotifyPropertyChanged(nameof(lblS04Color)); } }
|
|
|
|
private System.Windows.Media.Brush _lblS05Color;
|
|
public System.Windows.Media.Brush lblS05Color { get { return _lblS05Color; } set { _lblS05Color = value; NotifyPropertyChanged(nameof(lblS05Color)); } }
|
|
|
|
private System.Windows.Media.Brush _lblS06Color;
|
|
public System.Windows.Media.Brush lblS06Color { get { return _lblS06Color; } set { _lblS06Color = value; NotifyPropertyChanged(nameof(lblS06Color)); } }
|
|
|
|
private System.Windows.Media.Brush _lblS07Color;
|
|
public System.Windows.Media.Brush lblS07Color { get { return _lblS07Color; } set { _lblS07Color = value; NotifyPropertyChanged(nameof(lblS07Color)); } }
|
|
|
|
private System.Windows.Media.Brush _lblS08Color;
|
|
public System.Windows.Media.Brush lblS08Color { get { return _lblS08Color; } set { _lblS08Color = value; NotifyPropertyChanged(nameof(lblS08Color)); } }
|
|
|
|
private System.Windows.Media.Brush _lblS09Color;
|
|
public System.Windows.Media.Brush lblS09Color { get { return _lblS09Color; } set { _lblS09Color = value; NotifyPropertyChanged(nameof(lblS09Color)); } }
|
|
|
|
private System.Windows.Media.Brush _lblS10Color;
|
|
public System.Windows.Media.Brush lblS10Color { get { return _lblS10Color; } set { _lblS10Color = value; NotifyPropertyChanged(nameof(lblS10Color)); } }
|
|
|
|
private System.Windows.Media.Brush _lblS11Color;
|
|
public System.Windows.Media.Brush lblS11Color { get { return _lblS11Color; } set { _lblS11Color = value; NotifyPropertyChanged(nameof(lblS11Color)); } }
|
|
|
|
|
|
|
|
|
|
public PickingViewModel()
|
|
{
|
|
lblS01Text = "-";
|
|
lblS02Text = "-";
|
|
lblS03Text = "-";
|
|
lblS04Text = "-";
|
|
lblS05Text = "-";
|
|
lblS06Text = "-";
|
|
lblS07Text = "-";
|
|
lblS08Text = "-";
|
|
lblS09Text = "-";
|
|
lblS10Text = "-";
|
|
lblS11Text = "-";
|
|
lblS01Color = progressCurrent;
|
|
lblS02Color = progressWating;
|
|
lblS03Color = progressWating;
|
|
lblS04Color = progressWating;
|
|
lblS05Color = progressWating;
|
|
lblS06Color = progressWating;
|
|
lblS07Color = progressWating;
|
|
lblS08Color = progressWating;
|
|
lblS09Color = progressWating;
|
|
lblS10Color = progressWating;
|
|
lblS11Color = progressWating;
|
|
|
|
|
|
InitProgressBar();
|
|
|
|
}
|
|
private void InitProgressBar()
|
|
{
|
|
ProgressBar = new List<ImageElement>();
|
|
ProgressBar.Add(new ImageElement() { Name = "Init", Image = Ui.ProductionControls.Enums.Img.Waiting });
|
|
ProgressBar.Add(new ImageElement() { Name = "Scan", Image = Ui.ProductionControls.Enums.Img.BarcodeScanner });
|
|
ProgressBar.Add(new ImageElement() { Name = "Connect", Image = Ui.ProductionControls.Enums.Img.Plugin });
|
|
ProgressBar.Add(new ImageElement() { Name = "Order data", Image = Ui.ProductionControls.Enums.Img.Cloud });
|
|
ProgressBar.Add(new ImageElement() { Name = "Compare", Image = Ui.ProductionControls.Enums.Img.Compare });
|
|
ProgressBar.Add(new ImageElement() { Name = "Compare Result", Image = Ui.ProductionControls.Enums.Img.Default });
|
|
ProgressBar.Add(new ImageElement() { Name = "Scan Build", Image = Ui.ProductionControls.Enums.Img.BarcodeScanner });
|
|
ProgressBar.Add(new ImageElement() { Name = "Scan Build Pressure", Image = Ui.ProductionControls.Enums.Img.BarcodeScanner });
|
|
|
|
}
|
|
public List<ImageElement> ProgressBar { get; internal set; }
|
|
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
protected virtual void NotifyPropertyChanged([CallerMemberName] String propertyName = "")
|
|
{
|
|
|
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
|
|
}
|
|
|
|
Task s;
|
|
|
|
public void StartPicking(CancellationToken cancle, string scannerPort, int slotNr)
|
|
{
|
|
ScannerPort = scannerPort;
|
|
SlotNr = slotNr;
|
|
CloseTask = false;
|
|
s = new Task(() => { PickingLoop(cancle); }, cancle);
|
|
s.Start();
|
|
}
|
|
public enum PickingStateMachine
|
|
{
|
|
Init,
|
|
WaitForScanning,
|
|
ScanningDone,
|
|
WaitForDetect,
|
|
GetOrderDetails,
|
|
Compare,
|
|
MeterDone,
|
|
MeterError,
|
|
StartCom,
|
|
WaitForBuildingMeterReady,
|
|
WaitForBuildingPressureReady,
|
|
LutUpdate,
|
|
JustSapProgress,
|
|
}
|
|
private PickingStateMachine sm = PickingStateMachine.Init;
|
|
|
|
private class BarScanner : IDisposable
|
|
{
|
|
private bool isRuning = false;
|
|
public String Input = "";
|
|
private String Port;
|
|
private CancellationToken Cancellation;
|
|
private Task WaitForScannerTask;
|
|
public BarScanner(string port, CancellationToken cancellation)
|
|
{
|
|
Port = port;
|
|
Cancellation = cancellation;
|
|
}
|
|
public void Start()
|
|
{
|
|
if (!isRuning)
|
|
{
|
|
if (Port == null)
|
|
{
|
|
return;
|
|
}
|
|
WaitForScannerTask = new Task(() =>
|
|
{
|
|
using (var a = new SerialPort(Port))
|
|
{
|
|
try
|
|
{
|
|
a.Open();
|
|
a.NewLine = "\r";
|
|
while (true)
|
|
{
|
|
if (Cancellation.IsCancellationRequested)
|
|
{
|
|
isRuning = false;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Input = a.ReadLine();
|
|
a.Close();
|
|
isRuning = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Input = ex.Message;
|
|
isRuning = false;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}, Cancellation);
|
|
WaitForScannerTask.Start();
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (WaitForScannerTask.Status != TaskStatus.Faulted && WaitForScannerTask.Status != TaskStatus.RanToCompletion && WaitForScannerTask.Status != TaskStatus.Canceled)
|
|
{
|
|
WaitForScannerTask.Dispose();
|
|
}
|
|
|
|
}
|
|
}
|
|
public void setState(string state)
|
|
{
|
|
State = state;
|
|
UpdateLogText($"Status:{State}");
|
|
}
|
|
private bool CloseTask = false;
|
|
public void Dispose()
|
|
{
|
|
|
|
while (!s.IsCompleted)
|
|
{
|
|
CloseTask = true;
|
|
}
|
|
|
|
|
|
}
|
|
public bool Compare(Dictionary<UInt32, UInt32> checkAppsIdVersion, uint Frequency, uint MeterSize, bool PressurePresent)
|
|
{
|
|
using (var Batch = new MeterBatch())
|
|
{
|
|
|
|
using (var meter = new GenesisMeter())
|
|
{
|
|
|
|
meter.SetupFromConfigFile(SlotNr);
|
|
Batch.AddMeter(meter);
|
|
setState("Am Zähler anmelden");
|
|
|
|
if ((bool)meter.Login())
|
|
{
|
|
meter.SetProcessState(Xylem.Common.Hardware.WaterMeter.WaterMeterCore.Consts.DisplayCodes.PickingStarted);
|
|
var ret = RunCheck(checkAppsIdVersion, Frequency, MeterSize, PressurePresent, meter);
|
|
lblS08Color = progressWating;
|
|
if (ret)
|
|
{
|
|
|
|
|
|
if (!meter.WriteRegister("POWERMON_BatteryQuantity", 2, true, true))
|
|
{
|
|
lblS08Text = "1";
|
|
lblS08Color = progressError;
|
|
ret = false;
|
|
}
|
|
|
|
|
|
var nowSeconds = meter.ReadRegister("POWERMON_TotalUsedSeconds");
|
|
var nowCharge = meter.ReadRegister("POWERMON_TotalUsedCharge", 8);
|
|
var mfgCharge = meter.ReadRegister("CUSTOMER_MfgCharge");
|
|
if (nowCharge == null || nowSeconds == null)
|
|
{
|
|
meter.WriteLog($"Batterie nicht lesbar");
|
|
lblS08Text = $"Batterie nicht lesbar";
|
|
lblS08Color = progressError;
|
|
ret = false;
|
|
}
|
|
else
|
|
{
|
|
var nowChargeV = BitConverter.ToUInt64(nowCharge.ToArray(), 0);
|
|
var nowSecondsV = BitConverter.ToUInt32(nowSeconds.ToArray(), 0);
|
|
var mfgChargeV = BitConverter.ToUInt32(mfgCharge.ToArray(), 0);
|
|
//// Time Span in h in mAhr In % with one battery is 100%
|
|
////(((total used change difference / (Time span / 3600) ) / 3600000) / 19000)*100
|
|
var loadAtH = ((((double)nowChargeV / ((double)nowSecondsV / 3600)) / 3600000) / (19000 * 2)) * 100;
|
|
var totalUsed = (((double)nowChargeV / 1000000 / 3.6) / ((19000 * 2))) * 100;
|
|
setState($"Battery Total Used {totalUsed}%");
|
|
setState($"Battery Total Charge {nowChargeV}uAs");
|
|
setState($"Battery MFG Charge {mfgChargeV}uAs");
|
|
|
|
if (totalUsed >= 5.0)
|
|
{
|
|
lblS08Text = $"Batterie über 5%";
|
|
lblS08Color = progressError;
|
|
ret = false;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
if (SkipProcessSteps == null || !SkipProcessSteps.SkipLUT)
|
|
{
|
|
|
|
if (ret)
|
|
{
|
|
|
|
|
|
lblS08Text = "2";
|
|
lblS08Color = progressDone;
|
|
lblS10Color = progressCurrent;
|
|
|
|
if (OrderDetails.MeterSize <= 1)
|
|
{
|
|
lblS10Color = progressDone;
|
|
lblS10Text = "Keine LUT für DN40/50";
|
|
}
|
|
else
|
|
{
|
|
StringBuilder sbUrl = new StringBuilder();
|
|
sbUrl.Append("http://10.49.40.25/MeterProcessState/api/FileUpToDate/GetLutFiles");
|
|
sbUrl.Append($"?Metersize={OrderDetails.MeterSize}");
|
|
sbUrl.Append($"&ForProd=true");
|
|
//?Metersize=2&Region=EMEA&
|
|
if (OrderDetails.FrequencyIndicator != 0)
|
|
{
|
|
//get ema
|
|
sbUrl.Append($"&Region=EMEA");
|
|
}
|
|
else
|
|
{
|
|
//get na
|
|
sbUrl.Append($"&Region=NA");
|
|
}
|
|
|
|
|
|
try
|
|
{
|
|
|
|
var retLut = LocalWebRequest.GetRequest(sbUrl.ToString(), 80000);
|
|
var a = JsonConvert.DeserializeObject<List<CordonelMetrologyLut>>(retLut);
|
|
|
|
if (a.Count == 1)
|
|
{
|
|
setState($"Vergleich abgeschlossen:{State}");
|
|
var lut = a.First();
|
|
lblS10Text = $"Update {lut.FileCrc.ToString("0x8")}";
|
|
|
|
|
|
var _meterLutUpdate = new MeterLutUpdate(meter);
|
|
if (_meterLutUpdate == null)
|
|
{
|
|
ret = false;
|
|
}
|
|
else
|
|
{
|
|
var loadResult = _meterLutUpdate.LoadLutFromStream(lut.FileName, lut.FileContent.ToList());
|
|
var updatResult = _meterLutUpdate.UpdateMeterLut();
|
|
if (loadResult && updatResult)
|
|
{
|
|
lblS10Text = $"{lut.FileName} in meter";
|
|
lblS10Color = progressDone;
|
|
}
|
|
else
|
|
{
|
|
Result = $"Fehler beim Update";
|
|
setState(Result);
|
|
lblS10Text = Result;
|
|
lblS10Color = progressError;
|
|
|
|
ret = false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
Result = $"Keine eindeutige LUT gefunden";
|
|
setState(Result);
|
|
lblS10Color = progressError;
|
|
lblS10Text = Result;
|
|
ret = false;
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Result = $"Fehler beim LUT Update";
|
|
setState(Result);
|
|
lblS10Color = progressError;
|
|
lblS10Text = Result;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
setState($"LUT wird nicht überprüft Sonderfreigabe#{SkipProcessSteps.Id} von {SkipProcessSteps.Name}");
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ret)
|
|
{
|
|
|
|
if (!meter.IsLoggedOn)
|
|
{
|
|
meter.ReLogin();
|
|
}
|
|
meter.SetProcessState(Xylem.Common.Hardware.WaterMeter.WaterMeterCore.Consts.DisplayCodes.PickingTested);
|
|
var url = $"{ServiceUrls.MeterProcessStateUrl()}SetPickingState?PcbID={meter.PcbId}&FertigungsauftragsNr={Order}";
|
|
var RetString = LocalWebRequest.PostRequestAsyncAndGetContent(url);
|
|
|
|
var result = false;
|
|
if (bool.TryParse(RetString, out result))
|
|
{
|
|
return result;
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
meter.SetProcessState(Xylem.Common.Hardware.WaterMeter.WaterMeterCore.Consts.DisplayCodes.PickingFailed);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool RunCheck(Dictionary<uint, uint> checkAppsIdVersion, uint Frequency, uint MeterSize, bool PressurePresent, GenesisMeter meter)
|
|
{
|
|
|
|
lblS04Color = progressWating;
|
|
|
|
|
|
|
|
|
|
setState($"Überprüfe Parameter");
|
|
if (Frequency == 0)
|
|
{
|
|
lblS04Text = "NA";
|
|
}
|
|
else
|
|
{
|
|
var FrequencyReadOut = RegisterConverter.ConvertTo<UInt32>(meter.ReadRegister("SENSUSRADIO_FrequencyIndicator"));
|
|
if (FrequencyReadOut != Frequency)
|
|
{
|
|
|
|
setState($"Falsche Frequenz! soll {Frequency}MHz ist {FrequencyReadOut}MHz");
|
|
meter.WriteLog(State);
|
|
lblS04Color = progressError;
|
|
return false;
|
|
}
|
|
lblS04Text = "EMEA \\" + Frequency;
|
|
lblS04Color = progressDone;
|
|
lblS05Color = progressWating;
|
|
}
|
|
|
|
|
|
|
|
|
|
//TODO: metersize check for bigger dn sizes!!!
|
|
//var MeterSizeReadOut = RegisterConverter.ConvertTo<UInt32>(meter.ReadRegister("GENESISFLOW_MeterSize"));
|
|
//if (MeterSizeReadOut != MeterSize)
|
|
//{
|
|
// setState($"Meter Dn falsch! soll {MeterSize}DN ist {MeterSizeReadOut}DN");
|
|
// meter.WriteLog(State);
|
|
// return false;
|
|
//}
|
|
|
|
//meter.WriteRegister("METROLOGYASST_PressurePresent", 1,true);
|
|
|
|
var PressureReadOut = RegisterConverter.ConvertTo<bool>(meter.ReadRegister("METROLOGYASST_PressurePresent"));
|
|
|
|
if (PressureReadOut == PressurePresent)
|
|
{
|
|
if (!PressurePresent)
|
|
{
|
|
lblS05Text = "Kein Drucksensor";
|
|
}
|
|
else
|
|
{
|
|
lblS05Text = "Drucksensor vorhanden";
|
|
}
|
|
lblS05Color = progressDone;
|
|
lblS06Color = progressCurrent;
|
|
|
|
}
|
|
else
|
|
{
|
|
if (!PressurePresent)
|
|
{
|
|
setState($"Pcb mit Drucksensor. Laut Auftrag keine verbaut");
|
|
lblS05Text = "Drucksensor vorhanden!";
|
|
meter.WriteLog(State);
|
|
}
|
|
else
|
|
{
|
|
setState($"Pcb ohne Drucksensor. Laut Auftrag soll eine verbaut werden");
|
|
lblS05Text = "ohne Drucksensor!";
|
|
meter.WriteLog(State);
|
|
}
|
|
lblS05Color = progressError;
|
|
}
|
|
|
|
|
|
|
|
if (SkipProcessSteps == null || !SkipProcessSteps.SkipFWCheck)
|
|
{
|
|
foreach (var item in checkAppsIdVersion)
|
|
{
|
|
try
|
|
{
|
|
var MeterFWApp = meter.MeterAppListVersion.First(a => item.Key == a.AppId);
|
|
if (MeterFWApp == null || MeterFWApp.Version != item.Value)
|
|
{
|
|
setState($"Falsche FW, bitte Updaten AppId:{item.Key} sollte {item.Value} haben, hat aber {MeterFWApp.Version}");
|
|
meter.WriteLog(State);
|
|
lblS06Color = progressError;
|
|
return false;
|
|
}
|
|
lblS06Text = MeterFWApp.StrVersion;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
setState($"Fehler beim auslesen der FW");
|
|
meter.WriteLog(State);
|
|
lblS06Text = State;
|
|
lblS06Color = progressError;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
setState($"Produktionsdatum wird nicht überprüft Sonderfreigabe#{SkipProcessSteps.Id} von {SkipProcessSteps.Name}");
|
|
}
|
|
|
|
|
|
lblS06Color = progressDone;
|
|
lblS07Color = progressCurrent;
|
|
|
|
try
|
|
{
|
|
meter.WriteRegister("METROLOGYASST_StoreConfiguration", 1);
|
|
Thread.Sleep(2500);
|
|
meter.Logout();
|
|
Thread.Sleep(2500);
|
|
meter.ReLogin();
|
|
|
|
|
|
var storeRet = meter.ReadRegister("METROLOGYASST_StoreConfiguration");
|
|
if (meter.PcbId != "18440026" && meter.PcbId != "193300058" && meter.PcbId != "194800276" && meter.PcbId != "201420255" && !storeRet.All(a => a.Equals(0)))
|
|
{
|
|
lblS07Text = "Filesystem corrupt";
|
|
setState($"Filesystem corrupt");
|
|
meter.WriteLog(State);
|
|
lblS07Color = progressError;
|
|
return false;
|
|
}
|
|
|
|
}
|
|
catch (Exception)
|
|
{
|
|
setState($"Fehler beim überprüfen des Filesystems");
|
|
meter.WriteLog(State);
|
|
lblS07Color = progressError;
|
|
lblS07Text = State;
|
|
return false;
|
|
}
|
|
lblS07Color = progressDone;
|
|
lblS07Text = "Filesystem i.O";
|
|
return true;
|
|
}
|
|
|
|
private PickingCompareItem OrderDetails;
|
|
private OrderOverViewCordonelWithPicking OrderOverview;
|
|
private BarScanner barScanner;
|
|
private string Order;
|
|
private string PcbId;
|
|
private SkipProcess SkipProcessSteps;
|
|
|
|
|
|
private string ScannerPort = "COM20";
|
|
private int SlotNr = 1;
|
|
//PickingState,PickingScanner,PickingSlot,PickingResult
|
|
private void PickingLoop(CancellationToken token)
|
|
{
|
|
var converter = new System.Windows.Media.BrushConverter();
|
|
while (!token.IsCancellationRequested && !CloseTask)
|
|
{
|
|
switch (sm)
|
|
{
|
|
case PickingStateMachine.Init:
|
|
setState("Initialisierung");
|
|
Slot = $"Inaktiv EP {SlotNr}";
|
|
Scanner = $"Geschlossen {ScannerPort}";
|
|
//CheckAllPorts?
|
|
|
|
sm = PickingStateMachine.StartCom;
|
|
InitProgressBar();
|
|
|
|
break;
|
|
case PickingStateMachine.StartCom:
|
|
OrderDetails = null;
|
|
OrderOverview = null;
|
|
Scanner = $"Öfffne {ScannerPort}";
|
|
//CheckAllPorts?
|
|
barScanner = new BarScanner(ScannerPort, token);
|
|
barScanner.Start();
|
|
|
|
sm = PickingStateMachine.WaitForScanning;
|
|
var c = (System.Windows.Media.Brush)converter.ConvertFromString("Aquamarine");
|
|
c.Freeze();
|
|
ResultColor = c;
|
|
|
|
lblS01Text = "-";
|
|
lblS02Text = "-";
|
|
lblS03Text = "-";
|
|
lblS04Text = "-";
|
|
lblS05Text = "-";
|
|
lblS06Text = "-";
|
|
lblS07Text = "-";
|
|
lblS08Text = "-";
|
|
lblS09Text = "-";
|
|
lblS10Text = "-";
|
|
lblS11Text = "-";
|
|
lblS01Color = progressWating;
|
|
lblS02Color = progressWating;
|
|
lblS03Color = progressWating;
|
|
lblS04Color = progressWating;
|
|
lblS05Color = progressWating;
|
|
lblS06Color = progressWating;
|
|
lblS07Color = progressWating;
|
|
lblS08Color = progressWating;
|
|
lblS09Color = progressWating;
|
|
lblS10Color = progressWating;
|
|
lblS11Color = progressWating;
|
|
|
|
|
|
|
|
break;
|
|
case PickingStateMachine.WaitForScanning:
|
|
Scanner = $"Offen {ScannerPort}";
|
|
if (State != $"Warte auf Scannereingabe({ScannerPort})")
|
|
{
|
|
setState($"Warte auf Scannereingabe({ScannerPort})");
|
|
}
|
|
|
|
if (barScanner != null && !String.IsNullOrEmpty(barScanner.Input))
|
|
{
|
|
if (barScanner.Input == "%Cordonel_SAP_100%" || barScanner.Input == "%Cordonel_SAP_101%")
|
|
{
|
|
sm = PickingStateMachine.JustSapProgress;
|
|
}
|
|
else
|
|
{
|
|
int o = 0;
|
|
if (int.TryParse(barScanner.Input, out o))
|
|
{
|
|
Order = barScanner.Input;
|
|
Scanner = $"Geschlossen {ScannerPort}";
|
|
barScanner = null;
|
|
|
|
|
|
sm = PickingStateMachine.WaitForDetect;
|
|
lblS01Text = Order;
|
|
lblS01Color = progressDone;
|
|
lblS02Color = progressWating;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PickingStateMachine.JustSapProgress:
|
|
|
|
using (var Batch = new MeterBatch())
|
|
{
|
|
|
|
using (var tryMeter = new GenesisMeter())
|
|
{
|
|
try
|
|
{
|
|
setState($"Warte auf Pcb");
|
|
Slot = $"Öffne EP {SlotNr}";
|
|
tryMeter.SetupFromConfigFile(SlotNr);
|
|
Batch.AddMeter(tryMeter);
|
|
tryMeter.Logout();
|
|
Log("Try to get PcbID");
|
|
PcbId = tryMeter.GetPcbId();
|
|
|
|
var hasDetect = !string.IsNullOrEmpty(PcbId);
|
|
|
|
if (hasDetect)
|
|
{
|
|
|
|
setState($"Pcb gefunden {PcbId}");
|
|
Log($"New PcbID detected {PcbId}");
|
|
//barScanner.Input = "%Cordonel_SAP_100%";
|
|
sm = PickingStateMachine.WaitForBuildingMeterReady;
|
|
|
|
}
|
|
else
|
|
{
|
|
Slot = $"Keine Konnektivität EP {SlotNr}";
|
|
lblS02Text = Slot;
|
|
Log($"No Meter found");
|
|
|
|
}
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log($"Error occur.{ Environment.NewLine} {e.Message}");
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case PickingStateMachine.WaitForDetect:
|
|
using (var Batch = new MeterBatch())
|
|
{
|
|
|
|
using (var tryMeter = new GenesisMeter())
|
|
{
|
|
try
|
|
{
|
|
setState($"Warte auf Pcb");
|
|
Slot = $"Öffne EP {SlotNr}";
|
|
tryMeter.SetupFromConfigFile(SlotNr);
|
|
Batch.AddMeter(tryMeter);
|
|
tryMeter.Logout();
|
|
Log("Try to get PcbID");
|
|
PcbId = tryMeter.GetPcbId();
|
|
|
|
var hasDetect = !string.IsNullOrEmpty(PcbId);
|
|
|
|
if (hasDetect)
|
|
{
|
|
|
|
setState($"Pcb gefunden {PcbId}");
|
|
Log($"New PcbID detected {PcbId}");
|
|
sm = PickingStateMachine.GetOrderDetails;
|
|
|
|
lblS02Text = PcbId;
|
|
lblS02Color = progressDone;
|
|
lblS03Color = progressWating;
|
|
|
|
}
|
|
else
|
|
{
|
|
Slot = $"Keine Konnektivität EP {SlotNr}";
|
|
lblS02Text = Slot;
|
|
Log($"No Meter found");
|
|
|
|
}
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log($"Error occur.{ Environment.NewLine} {e.Message}");
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
case PickingStateMachine.GetOrderDetails:
|
|
|
|
setState($"Lade Auftragsdaten {Order}");
|
|
var retCode = 0;
|
|
var str = LocalWebRequest.GetRequestWithError($"{ServiceUrls.GenesisFinalCheckServiceUrl()}GetOrderOverview?ProductionOrderNumber={Order}&CheckPcbId={PcbId}", out retCode, 35000);
|
|
if (str.Contains("The request is invalid"))
|
|
{
|
|
Result = "Auftrag nicht gefunden";
|
|
lblS03Text = Result;
|
|
lblS03Color = progressError;
|
|
sm = PickingStateMachine.MeterError;
|
|
break;
|
|
}
|
|
if (retCode == 417)
|
|
{
|
|
sm = PickingStateMachine.MeterError;
|
|
Result = "Keine Radio Parameter";
|
|
lblS03Text = Result;
|
|
UpdateLogText(Result, true);
|
|
lblS03Color = progressError;
|
|
}
|
|
else
|
|
{
|
|
OrderOverview = JsonConvert.DeserializeObject<OrderOverViewCordonelWithPicking>(str);
|
|
OrderDetails = OrderOverview.PickingCompareItem;
|
|
|
|
if (OrderOverview.OrderOverViewCordonel.Count == OrderOverview.OrderOverViewCordonel.AssignedPicking)
|
|
{
|
|
Result = "Auftrag schon komplett";
|
|
lblS03Text = Result;
|
|
lblS03Color = progressError;
|
|
UpdateLogText(Result, true);
|
|
sm = PickingStateMachine.MeterError;
|
|
|
|
}
|
|
else
|
|
{
|
|
setState($"Auftragsdaten geladen {Order}");
|
|
|
|
|
|
|
|
var url = ServiceUrls.MeterProcessStateUrl();
|
|
url = url + $"GetCordonelSkipProcessStates?OrderNumber={Order}&PcbId={PcbId}";
|
|
var tmp = 0;
|
|
var retStr = LocalWebRequest.GetRequestWithError(url, out tmp);
|
|
|
|
SkipProcessSteps = new SkipProcess();
|
|
if (tmp == 200)
|
|
{
|
|
SkipProcessSteps = JsonConvert.DeserializeObject<SkipProcess>(retStr);
|
|
}
|
|
sm = PickingStateMachine.Compare;
|
|
|
|
|
|
lblS03Text = $"Nr {OrderOverview.OrderOverViewCordonel.AssignedPicking + 1 } von {OrderOverview.OrderOverViewCordonel.Count}";
|
|
lblS03Color = progressDone;
|
|
lblS04Color = progressCurrent;
|
|
|
|
}
|
|
}
|
|
|
|
break;
|
|
case PickingStateMachine.Compare:
|
|
//Compare
|
|
setState($"Vergleiche Auftragsdaten {Order} mit Pcb Eigenschaften");
|
|
|
|
var minDate = DateTime.Now;
|
|
|
|
|
|
lblS09Color = progressCurrent;
|
|
minDate = minDate.AddMonths(OrderOverview.OrderOverViewCordonel.Count < 5 ? -9 : -3);
|
|
setState($"Register wurde am {OrderOverview.KitronProductionDate } hergestellt, für diesen Auftrag ist muss das Register vor {minDate} hergestellt worden sein");
|
|
lblS09Text = $"{OrderOverview.KitronProductionDate}";
|
|
if (SkipProcessSteps == null || !SkipProcessSteps.SkipBatteyCheck)
|
|
{
|
|
if (OrderOverview.KitronProductionDate <= minDate)
|
|
{
|
|
setState($"Fehlgeschlagen Register ist zu alt! Bitte QS informieren. KitronProductionDate:{OrderOverview.KitronProductionDate }");
|
|
|
|
sm = PickingStateMachine.MeterError;
|
|
lblS09Color = progressError;
|
|
var b = (System.Windows.Media.Brush)converter.ConvertFromString("#FFFF00");
|
|
b.Freeze();
|
|
ResultColor = b;
|
|
|
|
break;
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
setState($"Produktionsdatum wird nicht überprüft Sonderfreigabe#{SkipProcessSteps.Id} von {SkipProcessSteps.Name}");
|
|
}
|
|
lblS09Color = progressDone;
|
|
|
|
if (Compare(OrderDetails.CheckAppsIdVersion, OrderDetails.FrequencyIndicator, OrderDetails.MeterSize, OrderDetails.PressurePresent))
|
|
{
|
|
|
|
sm = PickingStateMachine.MeterDone;
|
|
}
|
|
else
|
|
{
|
|
sm = PickingStateMachine.MeterError;
|
|
var b = (System.Windows.Media.Brush)converter.ConvertFromString("#FF8000");
|
|
b.Freeze();
|
|
ResultColor = b;
|
|
}
|
|
break;
|
|
|
|
|
|
case PickingStateMachine.MeterError:
|
|
OrderDetails = null;
|
|
OrderOverview = null;
|
|
setState($"Vergleich abgeschlossen:{State}");
|
|
Result = $"Vergleich fertig fehlgeschlagen";
|
|
Thread.Sleep(10000);
|
|
sm = PickingStateMachine.StartCom;
|
|
|
|
break;
|
|
|
|
case PickingStateMachine.MeterDone:
|
|
|
|
|
|
setState($"Vergleich abgeschlossen warten auf Montage Rückmeldung");
|
|
Result = $"Pcb {PcbId} wurde dem Auftrag {Order} hinzugefügt";
|
|
|
|
Scanner = $"Öfffne {ScannerPort}";
|
|
barScanner = new BarScanner(ScannerPort, token);
|
|
HistoryText = $"{HistoryText} {Environment.NewLine}{Order}({OrderOverview.OrderOverViewCordonel.AssignedPicking + 1 }/{ OrderOverview.OrderOverViewCordonel.Count})";
|
|
barScanner.Start();
|
|
sm = PickingStateMachine.WaitForBuildingMeterReady;
|
|
Thread.Sleep(10000);
|
|
//CheckAllPorts?
|
|
ProgressBar.Where(n => n.Name == "Scan Build").First().State = Ui.ProductionControls.Enums.ImgStatus.InProgress;
|
|
|
|
|
|
|
|
break;
|
|
case PickingStateMachine.WaitForBuildingMeterReady:
|
|
|
|
if (barScanner != null && !String.IsNullOrEmpty(barScanner.Input))
|
|
{
|
|
|
|
if (barScanner.Input == "%Cordonel_SAP_100%")
|
|
{
|
|
barScanner = null;
|
|
ProgressBar.Where(n => n.Name == "Scan Build").First().State = Ui.ProductionControls.Enums.ImgStatus.Success;
|
|
var url = ServiceUrls.MeterProcessStateUrl();
|
|
url = url + $"setSapState?PcbID={PcbId}&code=100&version=1";
|
|
try
|
|
{
|
|
LocalWebRequest.PostRequestAsync(url);
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
}
|
|
|
|
if (OrderDetails != null && OrderDetails.PressurePresent)
|
|
{
|
|
barScanner = new BarScanner(ScannerPort, token);
|
|
|
|
barScanner.Start();
|
|
setState($"Montage Rückmeldung erhalten, Montage des Drucksensors bestätigen");
|
|
sm = PickingStateMachine.WaitForBuildingPressureReady;
|
|
ProgressBar.Where(n => n.Name == "Scan Build Pressure").First().State = Ui.ProductionControls.Enums.ImgStatus.InProgress;
|
|
}
|
|
else
|
|
{
|
|
setState($"Montage Rückmeldung erhalten, auftrag Scannen");
|
|
sm = PickingStateMachine.StartCom;
|
|
Thread.Sleep(5000);
|
|
|
|
|
|
var b = (System.Windows.Media.Brush)converter.ConvertFromString("#419C14");
|
|
b.Freeze();
|
|
ResultColor = b;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case PickingStateMachine.WaitForBuildingPressureReady:
|
|
|
|
if (barScanner != null && !String.IsNullOrEmpty(barScanner.Input))
|
|
{
|
|
|
|
if (barScanner.Input == "%Cordonel_SAP_101%")
|
|
{
|
|
barScanner = null;
|
|
var url = ServiceUrls.MeterProcessStateUrl();
|
|
url = url + $"setSapState?PcbID={PcbId}&code=101&version=1";
|
|
try
|
|
{
|
|
LocalWebRequest.PostRequestAsync(url);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
}
|
|
|
|
var b = (System.Windows.Media.Brush)converter.ConvertFromString("#419C14");
|
|
b.Freeze();
|
|
ResultColor = b;
|
|
Thread.Sleep(5000);
|
|
setState($"Montage Rückmeldung erhalten, auftrag Scannen");
|
|
|
|
sm = PickingStateMachine.StartCom;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
Thread.Sleep(1000);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
private void Log(string v)
|
|
{
|
|
//throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
|
|
}
|