913 lines
32 KiB
C#
913 lines
32 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using Logic.ProductionToProductMapper.Cordonel;
|
|
using Newtonsoft.Json;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.Applications.Const;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisCore;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisCore.Consts;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisFile;
|
|
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
|
|
using Xylem.Common.Logic.ProductionOrderCore.OrderData;
|
|
using Xylem.Common.Logic.SoftwareAccessHelper;
|
|
using Xylem.Common.Utils.ProcessExec.EventArguments;
|
|
|
|
|
|
namespace Xylem.Common.Ui.GenesisToolBox
|
|
{
|
|
/// <summary>
|
|
/// FW update form
|
|
/// </summary>
|
|
public partial class FrmLutUpdate : Form
|
|
{
|
|
#region Variables
|
|
private readonly MeterBatch _meterBatch = new MeterBatch();
|
|
private GenesisMeter _currentGenesis;
|
|
private const String StrConnecting = "Connecting to PCB";
|
|
private const String StrNotConnected = "NOT CONNECTED";
|
|
private const String StrPartPcbConnected = "PCB ID: ";
|
|
private const String StrOverallProcess = "Overall Process";
|
|
|
|
private MeterLutUpdate _meterLutUpdate;
|
|
|
|
private String _lastFwUpdateState;
|
|
private Int32 _lastSingleProgress;
|
|
private DateTimeOffset _startTime;
|
|
private Boolean _resetTimeMeasurement;
|
|
private readonly Boolean _updateGui = true;
|
|
private Boolean _lutFileValid;
|
|
|
|
private Boolean _tryConnectPcb;
|
|
private Boolean _lutFileSuccessfulWritten;
|
|
private const String StrUpdateErrorMessage = "METROLOGY LOOKUP TABLE UPDATE FAILED!";
|
|
private const String StrUpdateSuccessMessage = "Metrology lookup table successfulley written!";
|
|
private const String StrLutFileInvalid = "LUT FILE INVALID";
|
|
private const String StrLutFileValid = "LUT file loaded";
|
|
|
|
// external update remarks form
|
|
private readonly FrmHistory _frmHistory = new FrmHistory();
|
|
|
|
private readonly Version _version;
|
|
|
|
// status information
|
|
private static readonly Color ColorDefault = Color.Black;
|
|
private static readonly Color ColorSuccess = Color.Green;
|
|
private static readonly Color ColorProcessFailed = Color.Red;
|
|
//private static readonly Color ColorOngoingProcess = Color.Blue;
|
|
//private static readonly Color ColorUnknownStatus = Color.Gray;
|
|
//private const String SuccessSign = @"✔";
|
|
//private const String FailedSign = @"✘";
|
|
|
|
private const String StrSeparator = "-----------------------------------------------------" +
|
|
"-----------------------------------------------------";
|
|
#endregion
|
|
|
|
#region FormControls
|
|
/// <summary>
|
|
/// Ctor FW update
|
|
/// </summary>
|
|
public FrmLutUpdate()
|
|
{
|
|
InitializeComponent();
|
|
var cultureInfo = new CultureInfo("en-GB");
|
|
Thread.CurrentThread.CurrentUICulture = cultureInfo;
|
|
Thread.CurrentThread.CurrentCulture = cultureInfo;
|
|
_version = Assembly.GetExecutingAssembly().GetName().Version;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clear data table and set genesis to not connected
|
|
/// </summary>
|
|
private void Init()
|
|
{
|
|
ProcessViewControl(false);
|
|
lblConnectPcb.Text = StrNotConnected;
|
|
lblConnectPcb.ForeColor = Color.Red;
|
|
lblWaitingForMeterResponse.Visible = false;
|
|
btnConnect.Enabled = true;
|
|
btnDownloadLutFile.ForeColor = Color.DarkGreen;
|
|
btnStopFwUpdate.ForeColor = Color.Red;
|
|
SetControlDownloadsLocked();
|
|
btnStopFwUpdate.Enabled = false;
|
|
btnOpenLutFile.Enabled = true;
|
|
btnClearDisplay.Enabled = false;
|
|
tbxPcbId.Visible = false;
|
|
}
|
|
|
|
private void FrmLutUpdate_Load(Object sender, EventArgs e)
|
|
{
|
|
var version = Assembly.GetExecutingAssembly().GetName().Version;
|
|
lblFwUpdateInfo.Text = $@"GTB Version: {version.Major}.{version.Minor}.{version.Build}";
|
|
_resetTimeMeasurement = true;
|
|
Init();
|
|
|
|
var xPosition = Location.X + Size.Width;
|
|
var yPosition = Location.Y;
|
|
if (_frmHistory != null)
|
|
{
|
|
_frmHistory.SetDesktopLocation(xPosition, yPosition);
|
|
_frmHistory.Show();
|
|
}
|
|
|
|
LogText($"GenesisToolBox: {_version.Major}.{_version.Minor}.{_version.Build}");
|
|
LogText(StrSeparator);
|
|
}
|
|
|
|
private void FrmLutUpdate_FormClosing(Object sender, FormClosingEventArgs e)
|
|
{
|
|
_frmHistory?.Close();
|
|
_currentGenesis?.Logout();
|
|
_meterBatch?.RemoveAllMeters();
|
|
_meterBatch?.Dispose();
|
|
if (_meterLutUpdate != null)
|
|
{
|
|
_meterLutUpdate.OnProcessUpdate -= ProcessUpdate_Event;
|
|
_meterLutUpdate.Dispose();
|
|
_meterLutUpdate = null;
|
|
}
|
|
|
|
Dispose();
|
|
}
|
|
|
|
private void cbComSlot_SelectedIndexChanged(Object sender, EventArgs e)
|
|
{
|
|
_resetTimeMeasurement = true;
|
|
Init();
|
|
}
|
|
#endregion
|
|
#region ActivationControls
|
|
|
|
private void SetControlDownloadsLocked()
|
|
{
|
|
btnDownloadLutFile.Enabled = false;
|
|
btnStopFwUpdate.Enabled = false;
|
|
btnConnect.Enabled = true;
|
|
}
|
|
|
|
private void SetControlsDownloadIsOngoing()
|
|
{
|
|
btnConnect.Enabled = false;
|
|
btnOpenLutFile.Enabled = false;
|
|
|
|
btnDownloadLutFile.Enabled = false;
|
|
btnClearDisplay.Enabled = false;
|
|
btnStopFwUpdate.Enabled = true;
|
|
}
|
|
|
|
private void SetControlsDownloadIsFinished()
|
|
{
|
|
_currentGenesis.RequestProtocol.AdditionalRetryTimeoutMs = 0;
|
|
btnConnect.Enabled = true;
|
|
btnOpenLutFile.Enabled = true;
|
|
|
|
btnDownloadLutFile.Enabled = true;
|
|
btnStopFwUpdate.Enabled = false;
|
|
btnClearDisplay.Enabled = true;
|
|
}
|
|
private void SetControlsDownloadEnabled()
|
|
{
|
|
btnConnect.Enabled = true;
|
|
btnOpenLutFile.Enabled = true;
|
|
|
|
btnDownloadLutFile.Enabled = true;
|
|
btnStopFwUpdate.Enabled = false;
|
|
btnClearDisplay.Enabled = true;
|
|
}
|
|
#endregion
|
|
|
|
#region BoardControls
|
|
/// <summary>
|
|
/// Establish connection
|
|
/// </summary>
|
|
/// <remarks date="2025-Aug-07" author="Thomas Wiedebusch">
|
|
/// - Compare the max supported FW versions of the configuration.json.
|
|
/// </remarks>
|
|
/// <remarks date="2025-Oct-02" author="Thomas Wiedebusch">
|
|
/// - Catch error message on unknown data type and kill meter.
|
|
/// </remarks>
|
|
private void Connect()
|
|
{
|
|
try
|
|
{
|
|
Init();
|
|
|
|
if (string.IsNullOrEmpty(cbComSlot.SelectedItem.ToString()) ||
|
|
!int.TryParse(cbComSlot.SelectedItem.ToString(), out var slotNr))
|
|
{
|
|
return;
|
|
}
|
|
lblOverall.Text = @"Login to Cordonel...";
|
|
|
|
ViewProgressPcb(true);
|
|
|
|
_currentGenesis?.DisposeMeter();
|
|
//dispose old meter
|
|
_meterBatch.RemoveAllMeters();
|
|
_currentGenesis = null;
|
|
|
|
//assign new meter and assign meter to FW update file if this exists
|
|
_currentGenesis = new GenesisMeter();
|
|
_currentGenesis.UseOfflinePasswords = cbxUseOfflinePwds.Checked;
|
|
_currentGenesis.SetupFromConfigFile(slotNr);
|
|
_meterBatch.AddMeter(_currentGenesis);
|
|
|
|
_currentGenesis.Configuration.UseRegisterWatchService = false;
|
|
_currentGenesis.Configuration.UseMinMaxCheck = false;
|
|
|
|
lblActualProcess.Text = @"Connecting to PCB...";
|
|
|
|
Task.Factory.StartNew(() =>
|
|
{
|
|
_meterBatch.MetersLogin();
|
|
|
|
if (!_currentGenesis.IsLoggedOn)
|
|
{
|
|
//this is needed from meter as an unsuccessful login requires a delay for the next trial
|
|
Thread.Sleep(2000);
|
|
_meterBatch.MetersLogin();
|
|
}
|
|
|
|
if (!_currentGenesis.IsLoggedOn)
|
|
{
|
|
return;
|
|
}
|
|
_meterLutUpdate?.AssignGenesis(_currentGenesis);
|
|
|
|
Invoke(new Action(() =>
|
|
{
|
|
lblConnectPcb.Text = StrPartPcbConnected;
|
|
tbxPcbId.Text = _currentGenesis.PcbId;
|
|
tbxPcbId.Visible = true;
|
|
tbxMeterFw.Text = _currentGenesis.FwVersion;
|
|
tbxMeterMeterSize.Text = _currentGenesis.MeterSize;
|
|
tbxMeterLutCrc.Text = _currentGenesis.LutCrc;
|
|
tbxRegion.Text = _currentGenesis.Region;
|
|
LogText("Meter FW Version: " + _currentGenesis.FwVersion);
|
|
LogText("Meter LUT CRC: " + _currentGenesis.LutCrc);
|
|
LogText("Meter Size: " + _currentGenesis.MeterSize);
|
|
LogText("Meter Region: " + _currentGenesis.Region);
|
|
if (_currentGenesis.RadioFrequencyMhz != null)
|
|
{
|
|
tbxRadio.Text = $@"{_currentGenesis.RadioFrequencyMhz}";
|
|
LogText($"Meter Radio Frequency [MHz]: {_currentGenesis.RadioFrequencyMhz}");
|
|
}
|
|
LogText("Configuration.json version: " + _currentGenesis.InterfaceInfo.InterfaceVersion);
|
|
lblConfigVersion.Text = @"Configuration Version: " + _currentGenesis.InterfaceInfo.InterfaceVersion;
|
|
lblConfigVersion.ForeColor = _currentGenesis.InterfaceSupportsFwVersion ?
|
|
Color.Green:
|
|
Color.Red;
|
|
if (!_currentGenesis.InterfaceSupportsFwVersion)
|
|
{
|
|
var text = "CONFIGURATION OUTDATED!\n" +
|
|
"The loaded \"configuration.json\" " +
|
|
$"version: {_currentGenesis.InterfaceInfo.InterfaceVersion}\n" +
|
|
$"does NOT support the Cordonel FW version: {_currentGenesis.FwVersion}!";
|
|
MessageBox.Show(text, @"FAILED", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
LogText(text);
|
|
}
|
|
else
|
|
{
|
|
LogText($"Configuration.json supports installed FW version: {_currentGenesis.FwVersion}");
|
|
}
|
|
lblConnectPcb.ForeColor = Color.Green;
|
|
CheckUpdateEnabled();
|
|
_currentGenesis.Logout();
|
|
LogInstalledMeterFw();
|
|
}));
|
|
}).ContinueWith(delegate
|
|
{
|
|
ViewProgressPcb(false);
|
|
});
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ViewProgressPcb(false);
|
|
MessageBox.Show(ex.Message, @"FAILED", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
LogErrorText(ex.Message);
|
|
// Dispose meter
|
|
_meterBatch.RemoveAllMeters();
|
|
// If meter is not already assigned to batch as the config reader may fail
|
|
_currentGenesis?.DisposeMeter();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region ProcessControls
|
|
private void ViewProgressPcb(Boolean isActive)
|
|
{
|
|
if (_updateGui)
|
|
{
|
|
if (isActive)
|
|
{
|
|
Invoke(new Action(() =>
|
|
{
|
|
_tryConnectPcb = true;
|
|
ProcessViewControl(true);
|
|
lblActualProcess.Text = StrConnecting;
|
|
lblOverall.Text = StrOverallProcess;
|
|
}));
|
|
}
|
|
else
|
|
{
|
|
Invoke(new Action(() =>
|
|
{
|
|
_tryConnectPcb = false;
|
|
ProcessViewControl(false);
|
|
btnClearDisplay.Enabled = true;
|
|
|
|
}));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// View all process bars and labels
|
|
/// </summary>
|
|
private void ProcessViewControl(Boolean view)
|
|
{
|
|
if (view)
|
|
{
|
|
lblActualProcess.Visible = true;
|
|
lblOverall.Visible = true;
|
|
barOverallProgressUpdate.Visible = true;
|
|
barSingleProgressUpdate.Visible = true;
|
|
_lastFwUpdateState = "";
|
|
tmrProgressUpdate.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
lblActualProcess.Visible = false;
|
|
lblOverall.Visible = false;
|
|
barOverallProgressUpdate.Visible = false;
|
|
barSingleProgressUpdate.Visible = false;
|
|
tmrProgressUpdate.Enabled = false;
|
|
_lastFwUpdateState = "";
|
|
lblWaitingForMeterResponse.Visible = false;
|
|
lblActualProcess.Text = "";
|
|
lblOverall.Text = "";
|
|
}
|
|
|
|
//common actions and settings
|
|
lblActualProcess.Update();
|
|
lblOverall.Update();
|
|
barOverallProgressUpdate.Value = 0;
|
|
barOverallProgressUpdate.Update();
|
|
barSingleProgressUpdate.Value = 0;
|
|
barSingleProgressUpdate.Update();
|
|
Update();
|
|
}
|
|
|
|
private void StartStopDownload(Boolean isActive)
|
|
{
|
|
if (isActive)
|
|
{
|
|
Invoke(new Action(() =>
|
|
{
|
|
ProcessViewControl(true);
|
|
tmrProgressUpdate.Enabled = true;
|
|
}));
|
|
}
|
|
else
|
|
{
|
|
Invoke(new Action(() =>
|
|
{
|
|
ProcessViewControl(false);
|
|
SetControlsDownloadIsFinished();
|
|
|
|
// update the display of the meter size, LUT CRC and region
|
|
tbxMeterFw.Text = _currentGenesis.FwVersion;
|
|
tbxMeterMeterSize.Text = _currentGenesis.MeterSize;
|
|
tbxMeterLutCrc.Text = _currentGenesis.LutCrc;
|
|
tbxRegion.Text = _currentGenesis.Region;
|
|
|
|
if (!_lutFileSuccessfulWritten)
|
|
{
|
|
lblLutFileLoadedInfo.ForeColor = Color.Red;
|
|
lblLutFileLoadedInfo.Text = StrUpdateErrorMessage;
|
|
var txt = StrUpdateErrorMessage;
|
|
if (!string.IsNullOrEmpty(_meterLutUpdate?.ErrorMessage))
|
|
{
|
|
txt += "\n";
|
|
txt += _meterLutUpdate?.ErrorMessage;
|
|
}
|
|
|
|
LogErrorText(txt);
|
|
MessageBoxShow(txt, @"FAILED",
|
|
MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
else
|
|
{
|
|
LogSuccessText(StrUpdateSuccessMessage);
|
|
MessageBoxShow(StrUpdateSuccessMessage, @"SUCCESS",
|
|
MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
}));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Display installed meter FW.
|
|
/// </summary>
|
|
/// <remarks date="2022-Mar-25" author="Thomas Wiedebusch">
|
|
/// - Init.
|
|
/// </remarks>
|
|
private void LogInstalledMeterFw()
|
|
{
|
|
if (_currentGenesis == null)
|
|
return;
|
|
LogText(StrSeparator);
|
|
LogText($"PCB ID: {_currentGenesis.PcbId}");
|
|
LogText($"Core Version: {_currentGenesis.StrCoreRevision}");
|
|
LogText("");
|
|
LogText("Installed Applications:");
|
|
|
|
foreach (var app in _currentGenesis.MeterAppListVersion)
|
|
{
|
|
var versionString = app.IsInstalled ? $"V: {app.StrVersion} - CRC: 0x{app.Crc:X4}" :
|
|
"App NOT Installed";
|
|
if (app.Status == MeterAppState.Unknown)
|
|
versionString = "COMMUNICATION ERROR";
|
|
|
|
LogText($"AppId: 0x{app.AppId:X2} - {versionString} - " + $"AppName: {app.AppName}");
|
|
|
|
if (app.IsInstalled)
|
|
{
|
|
var appVersion = new CordonelAppVersion(app.AppId, app.StrVersion);
|
|
|
|
// Copy metrology update permission
|
|
if (app.AppName == MetrologyDefinition.MetrologyName &&
|
|
_currentGenesis.MetrologyUpgradePermission != MetrologyDefinition.MetrologyUpgradePermitted)
|
|
{
|
|
appVersion.IsUpdateable = false;
|
|
}
|
|
}
|
|
}
|
|
LogText(StrSeparator);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clear history window.
|
|
/// </summary>
|
|
/// <remarks date="2021-Jan-05" author="Thomas Wiedebusch">
|
|
/// - Initial
|
|
/// </remarks>
|
|
private void ClearHistoryWindow()
|
|
{
|
|
if (_frmHistory != null && _frmHistory.rtbHistory.InvokeRequired)
|
|
{
|
|
_frmHistory.rtbHistory.Invoke(new Action(() => { _frmHistory.rtbHistory.Clear(); }));
|
|
}
|
|
else
|
|
_frmHistory?.rtbHistory.Clear();
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Output exclusively to user update remarks text window.
|
|
/// </summary>
|
|
/// <remarks date="2021-Apr-26" author="Thomas Wiedebusch">
|
|
/// - Color added.
|
|
/// </remarks>
|
|
private void LogText(String txtHistory)
|
|
{
|
|
InfoWindowColoredText(txtHistory, ColorDefault);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Output exclusively to user update remarks text window.
|
|
/// </summary>
|
|
private void LogErrorText(String txtHistory)
|
|
{
|
|
InfoWindowColoredText(txtHistory, ColorProcessFailed);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Output exclusively to user update remarks text window.
|
|
/// </summary>
|
|
private void LogSuccessText(String txtHistory)
|
|
{
|
|
InfoWindowColoredText(txtHistory, ColorSuccess);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Output exclusively to user update remarks text window.
|
|
/// </summary>
|
|
private void InfoWindowColoredText(String txtHistory, Color color)
|
|
{
|
|
if (_frmHistory?.rtbHistory == null)
|
|
return;
|
|
Invoke(new Action(() =>
|
|
{
|
|
_frmHistory.rtbHistory.SuspendLayout();
|
|
_frmHistory.rtbHistory.SelectionStart = _frmHistory.rtbHistory.Text.Length;
|
|
_frmHistory.rtbHistory.SelectionLength = 0;
|
|
_frmHistory.rtbHistory.SelectionColor = color;
|
|
_frmHistory.rtbHistory.AppendText($"{txtHistory}{Environment.NewLine}");
|
|
_frmHistory.rtbHistory.SelectionColor = _frmHistory.rtbHistory.ForeColor;
|
|
_frmHistory.rtbHistory.ScrollToCaret();
|
|
_frmHistory.rtbHistory.ResumeLayout();
|
|
}));
|
|
}
|
|
#endregion
|
|
|
|
#region Checks
|
|
private void CheckUpdateEnabled()
|
|
{
|
|
//this check has been placed here to force display update
|
|
if (_meterLutUpdate != null && _currentGenesis != null && _lutFileValid)
|
|
{
|
|
SetControlsDownloadEnabled();
|
|
return;
|
|
}
|
|
SetControlDownloadsLocked();
|
|
}
|
|
#endregion
|
|
|
|
#region Events
|
|
|
|
/// <summary>
|
|
/// Process update event for displaying messages in history window
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
/// <remarks date="2020-Dec-10" author="Thomas Wiedebusch">
|
|
/// - Initial
|
|
/// </remarks>
|
|
public virtual void ProcessUpdate_Event(Object sender, ProcessExecEventArgs e)
|
|
{
|
|
LogText(e.OverallProcessMessage);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TimerControls
|
|
private void tmrProgressUpdate_Tick(Object sender, EventArgs e)
|
|
{
|
|
//cbxManualControl.Visible = true;
|
|
if (_tryConnectPcb)
|
|
{
|
|
barOverallProgressUpdate.Value = barOverallProgressUpdate.Value + 1 > 100 ? 0 :
|
|
barOverallProgressUpdate.Value + 1;
|
|
barSingleProgressUpdate.Value = barSingleProgressUpdate.Value + 4 > 100 ? 0 :
|
|
barSingleProgressUpdate.Value + 4;
|
|
lblOverall.Text = StrOverallProcess;
|
|
}
|
|
else
|
|
{
|
|
lblOverall.Text = _meterLutUpdate?.GetLutUpdateStateOperation();
|
|
lblActualProcess.Text = _meterLutUpdate?.GetActualOperation();
|
|
|
|
var overallProgress = (Int32)(_meterLutUpdate?.OverallProcessCtrPercent ?? 0);
|
|
if (overallProgress < 0)
|
|
overallProgress = 0;
|
|
barOverallProgressUpdate.Value = overallProgress > 100 ? 100 : overallProgress;
|
|
barOverallProgressUpdate.Update();
|
|
|
|
var singleProgress = (Int32)(_meterLutUpdate?.SingleFileProcessCtrPercent ?? 0);
|
|
if (_meterLutUpdate?.GetActualOperation() != _lastFwUpdateState)
|
|
{
|
|
_lastFwUpdateState = _meterLutUpdate?.GetActualOperation();
|
|
lblWaitingForMeterResponse.Visible = false;
|
|
}
|
|
else
|
|
{
|
|
//if the communication gets frozen
|
|
lblWaitingForMeterResponse.Visible = _lastSingleProgress == singleProgress;
|
|
}
|
|
|
|
barSingleProgressUpdate.Value = singleProgress > 100 ? 100 : singleProgress;
|
|
_lastSingleProgress = singleProgress;
|
|
barSingleProgressUpdate.Update();
|
|
}
|
|
SetTimeDisplay();
|
|
Update();
|
|
}
|
|
|
|
private void SetTimeDisplay()
|
|
{
|
|
var time = DateTimeOffset.UtcNow;
|
|
var timeSpan = time - _startTime;
|
|
lblUpdateTime.Text = $@"{(UInt32)timeSpan.TotalMinutes}:{timeSpan.Seconds:00}";
|
|
}
|
|
#endregion
|
|
#region Buttons
|
|
private void btnConnect_Click(Object sender, EventArgs e)
|
|
{
|
|
if (_resetTimeMeasurement)
|
|
{
|
|
_startTime = DateTimeOffset.UtcNow;
|
|
_resetTimeMeasurement = false;
|
|
}
|
|
Connect();
|
|
|
|
}
|
|
|
|
private void btnOpenLutFile_Click(Object sender, EventArgs e)
|
|
{
|
|
if (dlgOpenLuFile.ShowDialog() != DialogResult.OK)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var lutFilePathName = dlgOpenLuFile.FileName;
|
|
|
|
lblLutFileLoadedInfo.Text = "";
|
|
tbxLutFilePathName.Text = lutFilePathName;
|
|
if (_meterLutUpdate == null)
|
|
{
|
|
_meterLutUpdate = new MeterLutUpdate(_currentGenesis);
|
|
_meterLutUpdate.OnProcessUpdate += ProcessUpdate_Event;
|
|
}
|
|
|
|
if (_meterLutUpdate == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (_meterLutUpdate.LoadLutFile(lutFilePathName))
|
|
{
|
|
lblLutFileLoadedInfo.ForeColor = Color.Green;
|
|
lblLutFileLoadedInfo.Text = StrLutFileValid;
|
|
tbxFileCrc.Text = $@"0x{_meterLutUpdate.LutFile.FileCrc:X4}";
|
|
tbxFileMeterSize.Text = MeterSizeConverter.ConvertMeterSizeEnumToSizeName(_meterLutUpdate.LutFile.MeterSize);
|
|
_lutFileValid = true;
|
|
|
|
LogText("File Meter Size: " + tbxFileMeterSize.Text);
|
|
LogText("File LUT CRC: " + tbxFileCrc.Text);
|
|
LogText(StrSeparator);
|
|
|
|
}
|
|
else
|
|
{
|
|
var txt = "";
|
|
if (!string.IsNullOrEmpty(_meterLutUpdate?.ErrorMessage))
|
|
{
|
|
txt += _meterLutUpdate?.ErrorMessage;
|
|
}
|
|
else
|
|
{
|
|
txt = StrLutFileInvalid;
|
|
}
|
|
|
|
LogErrorText(txt);
|
|
lblLutFileLoadedInfo.ForeColor = Color.Red;
|
|
lblLutFileLoadedInfo.Text = txt;
|
|
tbxFileCrc.Text = @" --- ";
|
|
tbxFileMeterSize.Text = @" --- ";
|
|
_lutFileValid = false;
|
|
}
|
|
|
|
CheckUpdateEnabled();
|
|
_resetTimeMeasurement = true;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Download LUT file
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void btnDownloadLutFile_Click(Object sender, EventArgs e)
|
|
{
|
|
if (_currentGenesis == null || _meterLutUpdate?.LutFile == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
lblLutFileLoadedInfo.Text = "";
|
|
SetControlsDownloadIsOngoing();
|
|
StartStopDownload(true);
|
|
|
|
_startTime = DateTimeOffset.UtcNow;
|
|
_resetTimeMeasurement = false;
|
|
|
|
|
|
Task.Factory.StartNew(() =>
|
|
{
|
|
_lutFileSuccessfulWritten = _meterLutUpdate.UpdateMeterLut();
|
|
Thread.Sleep(1000);
|
|
}).ContinueWith(delegate
|
|
{
|
|
StartStopDownload(false);
|
|
});
|
|
}
|
|
|
|
private void btnStopFwUpdate_Click(Object sender, EventArgs e)
|
|
{
|
|
if (_meterLutUpdate != null)
|
|
{
|
|
_meterLutUpdate.StopUpdateProcess = true;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
#region ExternalCalls
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public MsgEventArgs LastMsgEvent;
|
|
|
|
/// <inheritdoc />
|
|
public class MsgEventArgs : EventArgs
|
|
{
|
|
/// <summary>
|
|
/// Text to display
|
|
/// </summary>
|
|
public String Text;
|
|
/// <summary>
|
|
/// Headline
|
|
/// </summary>
|
|
public String Caption;
|
|
/// <summary>
|
|
/// Buttons
|
|
/// </summary>
|
|
public MessageBoxButtons Buttons;
|
|
/// <summary>
|
|
/// Icon
|
|
/// </summary>
|
|
public MessageBoxIcon Icon;
|
|
}
|
|
/// <summary>
|
|
/// Message pop up event handler
|
|
/// </summary>
|
|
public event EventHandler<MsgEventArgs> OnMsgPopUp;
|
|
private void MessageBoxShow(String text, String caption, MessageBoxButtons buttons, MessageBoxIcon icon)
|
|
{
|
|
if (_updateGui)
|
|
{
|
|
MessageBox.Show(text, caption, buttons, icon);
|
|
}
|
|
else
|
|
{
|
|
LastMsgEvent = new MsgEventArgs() { Text = text, Caption = caption, Buttons = buttons, Icon = icon };
|
|
OnMsgPopUp?.Invoke(this, LastMsgEvent);
|
|
}
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
private void SwitchView(Object sender, EventArgs e)
|
|
{
|
|
btnLoadfromDb.Enabled = false;
|
|
var file = rbtFile.Checked;
|
|
cbxDbLuts.Visible = !file;
|
|
lblSelectDb.Visible = !file;
|
|
btnLoadfromDb.Visible = !file;
|
|
|
|
lvlSelechtFile.Visible = file;
|
|
tbxLutFilePathName.Visible = file;
|
|
btnOpenLutFile.Visible = file;
|
|
if (!file)
|
|
{
|
|
LoadDbLuts(rbtProd.Checked);
|
|
}
|
|
|
|
}
|
|
|
|
private void LoadDbLuts(Boolean prod)
|
|
{
|
|
|
|
var sbUrl = new StringBuilder();
|
|
sbUrl.Append("http://10.49.40.25/MeterProcessState/api/FileUpToDate/GetLutFiles");
|
|
//sbUrl.Append("http://localhost:56011/api/FileUpToDate/GetLutFiles");
|
|
//sbUrl.Append($"?DataLength={_DataLength}");
|
|
//sbUrl.Append($"&version={_Version}");
|
|
//sbUrl.Append($"&crc={_FileCrc}");
|
|
//sbUrl.Append($"&Metersize={_MeterSize.GetHashCode()}");
|
|
//sbUrl.Append($"&Region={_StrLutRegion}");
|
|
try
|
|
{
|
|
|
|
var ret = LocalWebRequest.GetRequest(sbUrl.ToString(), 80000);
|
|
|
|
|
|
var a = JsonConvert.DeserializeObject<List<CordonelMetrologyLut>>(ret);
|
|
cbxDbLuts.SelectedIndex = -1;
|
|
cbxDbLuts.Items.Clear();
|
|
|
|
if (a == null) return;
|
|
foreach (var item in a)
|
|
{
|
|
if (!prod || item.CurrentVersionForProd)
|
|
{
|
|
cbxDbLuts.Items.Add(item);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
private void cbxDbLuts_SelectedIndexChanged(Object sender, EventArgs e)
|
|
{
|
|
if (cbxDbLuts.SelectedItem is CordonelMetrologyLut)
|
|
{
|
|
btnLoadfromDb.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
btnLoadfromDb.Enabled = false;
|
|
}
|
|
}
|
|
|
|
private void btnLoadfromDb_Click(Object sender, EventArgs e)
|
|
{
|
|
if (cbxDbLuts.SelectedItem is CordonelMetrologyLut lut)
|
|
{
|
|
lblLutFileLoadedInfo.Text = "";
|
|
tbxLutFilePathName.Text = $@"fromDB{lut.FileName}";
|
|
if (_meterLutUpdate == null)
|
|
{
|
|
_meterLutUpdate = new MeterLutUpdate(_currentGenesis);
|
|
_meterLutUpdate.OnProcessUpdate += ProcessUpdate_Event;
|
|
}
|
|
|
|
if (_meterLutUpdate == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (_meterLutUpdate.LoadLutFromStream(lut.FileName, lut.FileContent.ToList()))
|
|
{
|
|
lblLutFileLoadedInfo.ForeColor = Color.Green;
|
|
lblLutFileLoadedInfo.Text = StrLutFileValid;
|
|
tbxFileCrc.Text = $@"0x{_meterLutUpdate.LutFile.FileCrc:X4}";
|
|
tbxFileMeterSize.Text = MeterSizeConverter.ConvertMeterSizeEnumToSizeName(_meterLutUpdate.LutFile.MeterSize);
|
|
_lutFileValid = true;
|
|
|
|
LogText("File Meter Size: " + tbxFileMeterSize.Text);
|
|
LogText("File LUT CRC: " + tbxFileCrc.Text);
|
|
LogText(StrSeparator);
|
|
|
|
}
|
|
else
|
|
{
|
|
var txt = "";
|
|
if (!string.IsNullOrEmpty(_meterLutUpdate?.ErrorMessage))
|
|
{
|
|
txt += _meterLutUpdate?.ErrorMessage;
|
|
}
|
|
else
|
|
{
|
|
txt = StrLutFileInvalid;
|
|
}
|
|
|
|
LogErrorText(txt);
|
|
lblLutFileLoadedInfo.ForeColor = Color.Red;
|
|
lblLutFileLoadedInfo.Text = txt;
|
|
tbxFileCrc.Text = @" --- ";
|
|
tbxFileMeterSize.Text = @" --- ";
|
|
_lutFileValid = false;
|
|
}
|
|
|
|
CheckUpdateEnabled();
|
|
_resetTimeMeasurement = true;
|
|
}
|
|
}
|
|
|
|
private void rbtProd_CheckedChanged(Object sender, EventArgs e)
|
|
{
|
|
|
|
}
|
|
|
|
private void btnClearDisplay_Click(Object sender, EventArgs e)
|
|
{
|
|
if (_currentGenesis == null)
|
|
return;
|
|
|
|
lblOverall.Text = @"Set display to normal operation";
|
|
lblOverall.Visible = true;
|
|
Update();
|
|
|
|
if (!_currentGenesis.IsLoggedOn)
|
|
{
|
|
_currentGenesis.ReLogin();
|
|
}
|
|
|
|
_currentGenesis.SetLcdText(true, new Byte[] { 0x00, 0x00, 0x00, 0x00 });
|
|
_currentGenesis.Logout();
|
|
lblOverall.Visible = false;
|
|
}
|
|
|
|
private void cbxUseOfflinePwds_CheckedChanged(Object sender, EventArgs e)
|
|
{
|
|
cbxUseOfflinePwds.ForeColor = cbxUseOfflinePwds.Checked ? Color.Red : Color.Black;
|
|
}
|
|
}
|
|
}
|
|
|