1295 lines
51 KiB
C#
1295 lines
51 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 System.Windows;
|
|
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.GenesisStatus;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.Registers;
|
|
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
|
|
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore.Consts;
|
|
using Xylem.Common.Logic.SoftwareAccessHelper;
|
|
using static Ui.ProductionControls.ctlPictureProgressBar;
|
|
|
|
// ReSharper disable UnusedMember.Global this is used for unimplemented members
|
|
|
|
namespace CordonelAssemblyLine.Model
|
|
{
|
|
internal class PickingViewModel : INotifyPropertyChanged
|
|
{
|
|
private String _stateMsg = "Warte auf Scanner";
|
|
private String _scannerMsg = "Keine Verbindung";
|
|
private String _slot = "-";
|
|
private String _result = "-";
|
|
|
|
private System.Windows.Media.Brush _resultColor;
|
|
|
|
/// <summary>
|
|
/// Color setting for result display in assembly process
|
|
/// </summary>
|
|
public System.Windows.Media.Brush ResultColor
|
|
{
|
|
get => _resultColor;
|
|
set
|
|
{
|
|
_resultColor = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// State text for logging and display as user interface
|
|
/// </summary>
|
|
public String State
|
|
{
|
|
get => _stateMsg;
|
|
set
|
|
{
|
|
_stateMsg = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
public String Scanner
|
|
{
|
|
get => _scannerMsg;
|
|
set
|
|
{
|
|
_scannerMsg = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
public void UpdateLogText(String text, Boolean 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 => _historyText;
|
|
set
|
|
{
|
|
_historyText = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private String _logText = "Start";
|
|
public String LogText
|
|
{
|
|
get => _logText;
|
|
set
|
|
{
|
|
_logText = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
public String Slot
|
|
{
|
|
get => _slot;
|
|
set
|
|
{
|
|
_slot = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
public String Result
|
|
{
|
|
get => _result;
|
|
set
|
|
{
|
|
_result = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private String _pLblS01Text;
|
|
public String lblS01Text
|
|
{
|
|
get => _pLblS01Text;
|
|
set
|
|
{
|
|
_pLblS01Text = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private String _pLblS02Text;
|
|
public String lblS02Text
|
|
{
|
|
get => _pLblS02Text;
|
|
set
|
|
{
|
|
_pLblS02Text = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private String _pLblS03Text;
|
|
public String lblS03Text
|
|
{
|
|
get => _pLblS03Text;
|
|
set
|
|
{
|
|
_pLblS03Text = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private String _pLblS04Text;
|
|
public String lblS04Text
|
|
{
|
|
get => _pLblS04Text;
|
|
set
|
|
{
|
|
_pLblS04Text = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private String _pLblS05Text;
|
|
public String lblS05Text
|
|
{
|
|
get => _pLblS05Text;
|
|
set
|
|
{
|
|
_pLblS05Text = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private String _pLblS06Text;
|
|
public String lblS06Text
|
|
{
|
|
get => _pLblS06Text;
|
|
set
|
|
{
|
|
_pLblS06Text = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private String _pLblS07Text;
|
|
public String lblS07Text
|
|
{
|
|
get => _pLblS07Text;
|
|
set
|
|
{
|
|
_pLblS07Text = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private String _pLblS08Text;
|
|
public String lblS08Text
|
|
{
|
|
get => _pLblS08Text;
|
|
set
|
|
{
|
|
_pLblS08Text = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private String _pLblS09Text;
|
|
public String lblS09Text
|
|
{
|
|
get => _pLblS09Text;
|
|
set
|
|
{
|
|
_pLblS09Text = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private String _pLblS10Text;
|
|
public String lblS10Text
|
|
{
|
|
get => _pLblS10Text;
|
|
set
|
|
{
|
|
_pLblS10Text = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private String _pLblS11Text;
|
|
|
|
public String lblS11Text
|
|
{
|
|
get => _pLblS11Text;
|
|
set
|
|
{
|
|
_pLblS11Text = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private readonly System.Windows.Media.Brush _progressWaiting =
|
|
(System.Windows.Media.Brush)new System.Windows.Media.BrushConverter().ConvertFromString("Aquamarine");
|
|
private readonly System.Windows.Media.Brush _progressCurrent =
|
|
(System.Windows.Media.Brush)new System.Windows.Media.BrushConverter().ConvertFromString("yellow");
|
|
private readonly System.Windows.Media.Brush _progressDone =
|
|
(System.Windows.Media.Brush)new System.Windows.Media.BrushConverter().ConvertFromString("green");
|
|
private readonly 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 => _lblS01Color;
|
|
set
|
|
{
|
|
_lblS01Color = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private System.Windows.Media.Brush _lblS02Color;
|
|
public System.Windows.Media.Brush lblS02Color
|
|
{
|
|
get => _lblS02Color;
|
|
set
|
|
{
|
|
_lblS02Color = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private System.Windows.Media.Brush _lblS03Color;
|
|
public System.Windows.Media.Brush lblS03Color
|
|
{
|
|
get => _lblS03Color;
|
|
set
|
|
{
|
|
_lblS03Color = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private System.Windows.Media.Brush _lblS04Color;
|
|
public System.Windows.Media.Brush lblS04Color
|
|
{
|
|
get => _lblS04Color;
|
|
set
|
|
{
|
|
_lblS04Color = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private System.Windows.Media.Brush _lblS05Color;
|
|
public System.Windows.Media.Brush lblS05Color
|
|
{
|
|
get => _lblS05Color;
|
|
set
|
|
{
|
|
_lblS05Color = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private System.Windows.Media.Brush _lblS06Color;
|
|
public System.Windows.Media.Brush lblS06Color
|
|
{
|
|
get => _lblS06Color;
|
|
set
|
|
{
|
|
_lblS06Color = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private System.Windows.Media.Brush _lblS07Color;
|
|
public System.Windows.Media.Brush lblS07Color
|
|
{
|
|
get => _lblS07Color;
|
|
set
|
|
{
|
|
_lblS07Color = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private System.Windows.Media.Brush _lblS08Color;
|
|
public System.Windows.Media.Brush lblS08Color
|
|
{
|
|
get => _lblS08Color;
|
|
set
|
|
{
|
|
_lblS08Color = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private System.Windows.Media.Brush _lblS09Color;
|
|
public System.Windows.Media.Brush lblS09Color
|
|
{
|
|
get => _lblS09Color;
|
|
set
|
|
{
|
|
_lblS09Color = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private System.Windows.Media.Brush _lblS10Color;
|
|
public System.Windows.Media.Brush lblS10Color
|
|
{
|
|
get => _lblS10Color;
|
|
set
|
|
{
|
|
_lblS10Color = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
private System.Windows.Media.Brush _lblS11Color;
|
|
public System.Windows.Media.Brush lblS11Color
|
|
{
|
|
get => _lblS11Color;
|
|
set
|
|
{
|
|
_lblS11Color = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
public PickingViewModel()
|
|
{
|
|
lblS01Text = "-";
|
|
lblS02Text = "-";
|
|
lblS03Text = "-";
|
|
lblS04Text = "-";
|
|
lblS05Text = "-";
|
|
lblS06Text = "-";
|
|
lblS07Text = "-";
|
|
lblS08Text = "-";
|
|
lblS09Text = "-";
|
|
lblS10Text = "-";
|
|
lblS11Text = "-";
|
|
lblS01Color = _progressCurrent;
|
|
lblS02Color = _progressWaiting;
|
|
lblS03Color = _progressWaiting;
|
|
lblS04Color = _progressWaiting;
|
|
lblS05Color = _progressWaiting;
|
|
lblS06Color = _progressWaiting;
|
|
lblS07Color = _progressWaiting;
|
|
lblS08Color = _progressWaiting;
|
|
lblS09Color = _progressWaiting;
|
|
lblS10Color = _progressWaiting;
|
|
lblS11Color = _progressWaiting;
|
|
|
|
|
|
InitProgressBar();
|
|
|
|
}
|
|
private void InitProgressBar()
|
|
{
|
|
ProgressBar = new List<ImageElement>
|
|
{
|
|
new ImageElement { Name = "Init", Image = Ui.ProductionControls.Enums.Img.Waiting },
|
|
new ImageElement { Name = "Scan", Image = Ui.ProductionControls.Enums.Img.BarcodeScanner },
|
|
new ImageElement { Name = "Connect", Image = Ui.ProductionControls.Enums.Img.Plugin },
|
|
new ImageElement { Name = "Order data", Image = Ui.ProductionControls.Enums.Img.Cloud },
|
|
new ImageElement { Name = "Compare", Image = Ui.ProductionControls.Enums.Img.Compare },
|
|
new ImageElement { Name = "Compare Result", Image = Ui.ProductionControls.Enums.Img.Default },
|
|
new ImageElement { Name = "Scan Build", Image = Ui.ProductionControls.Enums.Img.BarcodeScanner },
|
|
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));
|
|
}
|
|
|
|
private Task _s;
|
|
|
|
/// <summary>
|
|
/// Initial start of assembling
|
|
/// </summary>
|
|
/// <param name="cancel"></param>
|
|
/// <param name="scannerPort"></param>
|
|
/// <param name="slotNr"></param>
|
|
public void StartPicking(CancellationToken cancel, String scannerPort, Int32 slotNr)
|
|
{
|
|
_scannerPort = scannerPort;
|
|
_slotNr = slotNr;
|
|
_closeTask = false;
|
|
_s = new Task(() => { PickingLoop(cancel); }, cancel);
|
|
_s.Start();
|
|
}
|
|
|
|
/// <summary>
|
|
/// States for assembly line, picking of single parts
|
|
/// </summary>
|
|
public enum PickingStateMachine
|
|
{
|
|
Init,
|
|
WaitForScanning,
|
|
ScanningDone,
|
|
WaitForDetect,
|
|
GetOrderDetails,
|
|
Compare,
|
|
MeterDone,
|
|
MeterError,
|
|
StartCom,
|
|
WaitForBuildingMeterReady,
|
|
WaitForBuildingPressureReady,
|
|
LutUpdate,
|
|
JustSapProgress,
|
|
}
|
|
private PickingStateMachine _state = PickingStateMachine.Init;
|
|
|
|
private class BarScanner : IDisposable
|
|
{
|
|
private Boolean _isRunning;
|
|
public String Input = "";
|
|
private readonly String _port;
|
|
private CancellationToken _cancellation;
|
|
private Task _waitForScannerTask;
|
|
public BarScanner(String port, CancellationToken cancellation)
|
|
{
|
|
_port = port;
|
|
_cancellation = cancellation;
|
|
}
|
|
public void Start()
|
|
{
|
|
if (!_isRunning)
|
|
{
|
|
if (_port == null)
|
|
{
|
|
return;
|
|
}
|
|
_waitForScannerTask = new Task(() =>
|
|
{
|
|
using (var a = new SerialPort(_port))
|
|
{
|
|
try
|
|
{
|
|
a.Open();
|
|
a.NewLine = "\r";
|
|
while (true)
|
|
{
|
|
if (_cancellation.IsCancellationRequested)
|
|
{
|
|
_isRunning = false;
|
|
break;
|
|
}
|
|
|
|
Input = a.ReadLine();
|
|
a.Close();
|
|
_isRunning = false;
|
|
break;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Input = ex.Message;
|
|
_isRunning = 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 Boolean _closeTask;
|
|
public void Dispose()
|
|
{
|
|
|
|
while (!_s.IsCompleted)
|
|
{
|
|
_closeTask = true;
|
|
}
|
|
|
|
|
|
}
|
|
public Boolean Compare(Dictionary<UInt32, UInt32> checkAppsIdVersion, UInt32 frequency, UInt32 meterSize, Boolean pressurePresent)
|
|
{
|
|
using (var batch = new MeterBatch())
|
|
{
|
|
|
|
using (var meter = new GenesisMeter())
|
|
{
|
|
|
|
meter.SetupFromConfigFile(_slotNr);
|
|
batch.AddMeter(meter);
|
|
SetState("Am Zähler anmelden");
|
|
|
|
if (meter.Login())
|
|
{
|
|
meter.SetProcessState(DisplayCodes.PickingStarted);
|
|
var ret = RunCheck(checkAppsIdVersion, frequency, meterSize, pressurePresent, meter);
|
|
lblS08Color = _progressWaiting;
|
|
if (ret)
|
|
{
|
|
|
|
|
|
if (!meter.WriteRegister("POWERMON_BatteryQuantity", 2, true, true))
|
|
{
|
|
lblS08Text = "1";
|
|
lblS08Color = _progressError;
|
|
ret = false;
|
|
}
|
|
|
|
meter.WriteRegister("POWERMON_StoreConfiguration", 1, true);
|
|
|
|
|
|
|
|
|
|
var genesisStatus = new GenesisStatus();
|
|
|
|
// this calculates all life time values
|
|
if (!GenesisStatusHandler.BuildLifeTimeInformation(meter, genesisStatus, out _))
|
|
{
|
|
meter.WriteLog("Batterie nicht lesbar");
|
|
lblS08Text = "Batterie nicht lesbar";
|
|
lblS08Color = _progressError;
|
|
ret = false;
|
|
}
|
|
else
|
|
{
|
|
var sbMSG = new StringBuilder();
|
|
sbMSG.AppendLine($"Pcb = {meter.PcbId}");
|
|
|
|
sbMSG.AppendLine($"POWERMON_TotalUsedSeconds = {genesisStatus.ExceededLifeTime_s}");
|
|
sbMSG.AppendLine($"POWERMON_TotalUsedCharge = {genesisStatus.DrainedBatteryLoad_uAs}");
|
|
sbMSG.AppendLine($"POWERMON_BatteryQuantity = {genesisStatus.BatteryQuantity}");
|
|
sbMSG.AppendLine($"POWERMON_BatteryMilliAHrRating = {genesisStatus.InitialBatteryLoad_mAh}");
|
|
sbMSG.AppendLine("");
|
|
sbMSG.AppendLine($"Remaining life time in years {genesisStatus.RemainingLifeTimeYears:F2}");
|
|
sbMSG.AppendLine($"Totally drained battery load in % {genesisStatus.DrainedBatteryLoadPercent:F2}");
|
|
|
|
if (genesisStatus.RemainingLifeTimeYears >= 21 || genesisStatus.DrainedBatteryLoadPercent <= 1)
|
|
{
|
|
lblS08Text = $"{genesisStatus.RemainingLifeTimeYears} Jahre";
|
|
}
|
|
else
|
|
{
|
|
lblS08Text = $"{genesisStatus.RemainingLifeTimeYears} Jahre";
|
|
lblS08Color = _progressError;
|
|
ret = false;
|
|
}
|
|
if (_orderDetails.FrequencyIndicator == 0)
|
|
{
|
|
if ((342000000 + (genesisStatus.ExceededLifeTime_s * 77.7)) <= genesisStatus.DrainedBatteryLoad_uAs)
|
|
{
|
|
lblS08Text = $"UNT Limit überschritten";
|
|
lblS08Color = _progressError;
|
|
ret = false;
|
|
}
|
|
}
|
|
meter.WriteLog(sbMSG.ToString());
|
|
}
|
|
}
|
|
|
|
if (_skipProcessSteps == null || !_skipProcessSteps.SkipLUT)
|
|
{
|
|
|
|
if (ret)
|
|
{
|
|
lblS08Text = "2";
|
|
lblS08Color = _progressDone;
|
|
lblS10Color = _progressCurrent;
|
|
|
|
|
|
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:0x8}";
|
|
|
|
var meterLutUpdate = new MeterLutUpdate(meter);
|
|
var loadResult = meterLutUpdate.LoadLutFromStream(lut.FileName, lut.FileContent.ToList());
|
|
var updateResult = meterLutUpdate.UpdateMeterLut();
|
|
if (loadResult && updateResult)
|
|
{
|
|
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)
|
|
{
|
|
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(DisplayCodes.PickingTested);
|
|
var url = $"{ServiceUrls.MeterProcessStateUrl()}SetPickingState?PcbID={meter.PcbId}&FertigungsauftragsNr={_order}";
|
|
var retString = LocalWebRequest.PostRequestAsyncAndGetContent(url);
|
|
|
|
if (bool.TryParse(retString, out var result))
|
|
{
|
|
return result;
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
meter.SetProcessState(DisplayCodes.PickingFailed);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private Boolean RunCheck(Dictionary<UInt32, UInt32> checkAppsIdVersion, UInt32 frequency, UInt32 meterSize, Boolean pressurePresent, GenesisMeter meter)
|
|
{
|
|
lblS04Color = _progressWaiting;
|
|
|
|
SetState("Überprüfe Parameter");
|
|
if (frequency == 0)
|
|
{
|
|
lblS04Text = "NA";
|
|
}
|
|
else
|
|
{
|
|
var frequencyReadOut = RegisterConverter.ByteArrayToValue<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 = _progressWaiting;
|
|
}
|
|
|
|
//TODO: metersize check for bigger dn sizes!!!
|
|
var meterSizeReadOut = RegisterConverter.ByteArrayToValue<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.ByteArrayToValue<Boolean>(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 keiner verbaut");
|
|
lblS05Text = "Drucksensor vorhanden!";
|
|
meter.WriteLog(State);
|
|
|
|
}
|
|
else
|
|
{
|
|
SetState("Pcb ohne Drucksensor. Laut Auftrag soll einer verbaut werden");
|
|
lblS05Text = "Ohne Drucksensor!";
|
|
meter.WriteLog(State);
|
|
}
|
|
lblS05Color = _progressError;
|
|
return false;
|
|
}
|
|
|
|
if (_skipProcessSteps == null || !_skipProcessSteps.SkipFWCheck)
|
|
{
|
|
if (!meter.InstalledFwVersion.HasValue || !checkAppsIdVersion.Any())
|
|
{
|
|
SetState("Fehler beim auslesen der FW");
|
|
meter.WriteLog(State);
|
|
lblS06Text = State;
|
|
lblS06Color = _progressError;
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (meter.InstalledFwVersion.Value != checkAppsIdVersion.FirstOrDefault().Value)
|
|
|
|
{
|
|
SetState($"Falsche FW, bitte Updaten! FW sollte {checkAppsIdVersion.FirstOrDefault().Value} haben, hat aber {meter.InstalledFwVersion.Value}");
|
|
meter.WriteLog(State);
|
|
lblS06Color = _progressError;
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
SetState($"Produktionsdatum wird nicht überprüft Sonderfreigabe Nr.:{_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 (!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 Int32 _slotNr = 1;
|
|
//PickingState,PickingScanner,PickingSlot,PickingResult
|
|
private void PickingLoop(CancellationToken token)
|
|
{
|
|
var converter = new System.Windows.Media.BrushConverter();
|
|
while (!token.IsCancellationRequested && !_closeTask)
|
|
{
|
|
try
|
|
{
|
|
switch (_state)
|
|
{
|
|
case PickingStateMachine.Init:
|
|
SetState("Initialisierung");
|
|
Slot = $"Inaktiv EP {_slotNr}";
|
|
Scanner = $"Geschlossen {_scannerPort}";
|
|
//CheckAllPorts?
|
|
|
|
_state = PickingStateMachine.StartCom;
|
|
InitProgressBar();
|
|
break;
|
|
|
|
case PickingStateMachine.StartCom:
|
|
_orderDetails = null;
|
|
_orderOverview = null;
|
|
Scanner = $"Öfffne {_scannerPort}";
|
|
//CheckAllPorts?
|
|
_barScanner = new BarScanner(_scannerPort, token);
|
|
_barScanner.Start();
|
|
|
|
_state = 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 = _progressWaiting;
|
|
lblS02Color = _progressWaiting;
|
|
lblS03Color = _progressWaiting;
|
|
lblS04Color = _progressWaiting;
|
|
lblS05Color = _progressWaiting;
|
|
lblS06Color = _progressWaiting;
|
|
lblS07Color = _progressWaiting;
|
|
lblS08Color = _progressWaiting;
|
|
lblS09Color = _progressWaiting;
|
|
lblS10Color = _progressWaiting;
|
|
lblS11Color = _progressWaiting;
|
|
break;
|
|
|
|
case PickingStateMachine.WaitForScanning:
|
|
Scanner = $"Offen {_scannerPort}";
|
|
if (State != $"Warte auf Scannereingabe({_scannerPort})")
|
|
{
|
|
SetState($"Warte auf Scannereingabe({_scannerPort})");
|
|
}
|
|
|
|
_barScanner.Input = "3238927";
|
|
|
|
if (_barScanner != null && !string.IsNullOrEmpty(_barScanner.Input))
|
|
{
|
|
if (_barScanner.Input == "%Cordonel_SAP_100%" || _barScanner.Input == "%Cordonel_SAP_101%")
|
|
{
|
|
_state = PickingStateMachine.JustSapProgress;
|
|
}
|
|
else
|
|
{
|
|
if (int.TryParse(_barScanner.Input, out _))
|
|
{
|
|
_order = _barScanner.Input;
|
|
Scanner = $"Geschlossen {_scannerPort}";
|
|
_barScanner = null;
|
|
|
|
_state = PickingStateMachine.WaitForDetect;
|
|
lblS01Text = _order;
|
|
lblS01Color = _progressDone;
|
|
lblS02Color = _progressWaiting;
|
|
}
|
|
}
|
|
}
|
|
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%";
|
|
_state = 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 = "250639533"; // tryMeter.GetPcbId();
|
|
|
|
var hasDetect = !string.IsNullOrEmpty(_pcbId);
|
|
|
|
if (hasDetect)
|
|
{
|
|
SetState($"Pcb gefunden {_pcbId}");
|
|
Log($"New PcbID detected {_pcbId}");
|
|
_state = PickingStateMachine.GetOrderDetails;
|
|
|
|
lblS02Text = _pcbId;
|
|
lblS02Color = _progressDone;
|
|
lblS03Color = _progressWaiting;
|
|
}
|
|
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 str = LocalWebRequest.GetRequestWithError($"{ServiceUrls.GenesisFinalCheckServiceUrl()}" +
|
|
$"GetOrderOverview?ProductionOrderNumber={_order}" +
|
|
$"&CheckPcbId={_pcbId}", out var retCode, 50000);
|
|
Log($"GetOrderOverview {retCode}");
|
|
if (str.Contains("The request is invalid"))
|
|
{
|
|
|
|
|
|
Result = "Auftrag nicht gefunden";
|
|
lblS03Text = Result;
|
|
lblS03Color = _progressError;
|
|
_state = PickingStateMachine.MeterError;
|
|
break;
|
|
}
|
|
if (retCode == 417)
|
|
{
|
|
_state = PickingStateMachine.MeterError;
|
|
Result = "Keine Funkparameter";
|
|
lblS03Text = Result;
|
|
UpdateLogText(Result);
|
|
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);
|
|
_state = PickingStateMachine.MeterError;
|
|
|
|
}
|
|
else
|
|
{
|
|
SetState($"Auftragsdaten geladen {_order}");
|
|
|
|
var url = ServiceUrls.MeterProcessStateUrl();
|
|
url += $"GetCordonelSkipProcessStates?OrderNumber={_order}&PcbId={_pcbId}";
|
|
var retStr = LocalWebRequest.GetRequestWithError(url, out var tmp, 10000);
|
|
|
|
_skipProcessSteps = new SkipProcess();
|
|
if (tmp == 200)
|
|
{
|
|
_skipProcessSteps = JsonConvert.DeserializeObject<SkipProcess>(retStr);
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show($"Auftragsdaten geladen {_order} Fehler ({tmp})");
|
|
}
|
|
_state = 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;
|
|
|
|
|
|
////Rule from J.Schulz, 9 months for customers with immediately usage here temporary decided on order volume
|
|
////minDate = minDate.AddMonths(_orderOverview.OrderOverViewCordonel.Count < 5 ? -9 : -3);
|
|
|
|
//// The production date has to be at least within the last 3 months from now backwards
|
|
//minDate = minDate.AddMonths(-3);
|
|
//SetState($"Register wurde am {_orderOverview.KitronProductionDate } hergestellt, für diesen Auftrag " +
|
|
// $"muss das Register nach dem {minDate} hergestellt worden sein");
|
|
//lblS09Text = $"{_orderOverview.KitronProductionDate}";
|
|
|
|
////TODO may be useful to introduce SkipRegisterOldness instead of SkipBatteyCheck will be used for oldness of register
|
|
//if (_skipProcessSteps == null || !_skipProcessSteps.SkipBatteyCheck)
|
|
//{
|
|
// if (_orderOverview.KitronProductionDate <= minDate)
|
|
// {
|
|
// SetState($"Fehlgeschlagen Register ist zu alt! Bitte QS informieren. Kitron-Produktionsdatum: {_orderOverview.KitronProductionDate }");
|
|
|
|
// _state = 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 Nr.:{_skipProcessSteps.Id} von {_skipProcessSteps.Name}");
|
|
//}
|
|
lblS09Color = _progressDone;
|
|
|
|
if (Compare(_orderDetails.CheckAppsIdVersion, _orderDetails.FrequencyIndicator, _orderDetails.MeterSize, _orderDetails.PressurePresent))
|
|
{
|
|
_state = PickingStateMachine.MeterDone;
|
|
}
|
|
else
|
|
{
|
|
_state = 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 fehlgeschlagen";
|
|
Thread.Sleep(10000);
|
|
_state = PickingStateMachine.StartCom;
|
|
break;
|
|
|
|
case PickingStateMachine.MeterDone:
|
|
SetState("Vergleich abgeschlossen, warte auf manuelle Montagerückmeldung");
|
|
Result = $"Pcb {_pcbId} wurde dem Auftrag {_order} hinzugefügt";
|
|
|
|
Scanner = $"Öffne {_scannerPort}";
|
|
_barScanner = new BarScanner(_scannerPort, token);
|
|
HistoryText = $"{HistoryText} {Environment.NewLine}{_order}({_orderOverview.OrderOverViewCordonel.AssignedPicking + 1 }/{ _orderOverview.OrderOverViewCordonel.Count})";
|
|
_barScanner.Start();
|
|
_state = PickingStateMachine.WaitForBuildingMeterReady;
|
|
Thread.Sleep(10000);
|
|
//CheckAllPorts?
|
|
ProgressBar.First(n => n.Name == "Scan Build").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.First(n => n.Name == "Scan Build").State = Ui.ProductionControls.Enums.ImgStatus.Success;
|
|
var url = ServiceUrls.MeterProcessStateUrl();
|
|
url += $"setSapState?PcbID={_pcbId}&code=100&version=1";
|
|
try
|
|
{
|
|
LocalWebRequest.PostRequestAsync(url);
|
|
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// ignored
|
|
}
|
|
|
|
if (_orderDetails != null && _orderDetails.PressurePresent)
|
|
{
|
|
_barScanner = new BarScanner(_scannerPort, token);
|
|
|
|
_barScanner.Start();
|
|
SetState("Montage Rückmeldung erhalten, Montage des Drucksensors bestätigen");
|
|
_state = PickingStateMachine.WaitForBuildingPressureReady;
|
|
ProgressBar.First(n => n.Name == "Scan Build Pressure").State = Ui.ProductionControls.Enums.ImgStatus.InProgress;
|
|
}
|
|
else
|
|
{
|
|
SetState("Montage Rückmeldung erhalten, Auftrag Scannen");
|
|
_state = 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 += $"setSapState?PcbID={_pcbId}&code=101&version=1";
|
|
try
|
|
{
|
|
LocalWebRequest.PostRequestAsync(url);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// ignored
|
|
}
|
|
|
|
var b = (System.Windows.Media.Brush)converter.ConvertFromString("#419C14");
|
|
b.Freeze();
|
|
ResultColor = b;
|
|
Thread.Sleep(5000);
|
|
SetState("Montage Rückmeldung erhalten, Auftrag Scannen");
|
|
|
|
_state = PickingStateMachine.StartCom;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
Thread.Sleep(1000);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log(ex.Message);
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
// ReSharper disable once UnusedParameter.Local
|
|
private void Log(String v)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
|
|
}
|