2633 lines
114 KiB
C#
2633 lines
114 KiB
C#
//...MF using LaaPackages.Features.Cordonel;
|
|
using Logic.ProductionToProductMapper.Cordonel;
|
|
using Newtonsoft.Json;
|
|
using NLog;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Drawing;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using Xylem.Common.CommonCore.Configuration;
|
|
using Xylem.Common.CommonCore.Consts;
|
|
using Xylem.Common.Hardware.Interfaces.Ports.PortCore;
|
|
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.Registers;
|
|
using Xylem.Common.Hardware.WaterMeter.Genesis.Registers.DataTypes;
|
|
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
|
|
using Xylem.Common.Logic.ProductionOrderCore.TestResults;
|
|
using Xylem.Common.Logic.SoftwareAccessHelper;
|
|
using Xylem.Common.Utils.Logging;
|
|
using Access = Xylem.Common.Hardware.WaterMeter.Genesis.Registers.Access;
|
|
using Register = Xylem.Common.Hardware.WaterMeter.Genesis.Registers.Register;
|
|
using GenesisCordonelInterface.API;
|
|
|
|
namespace GenesisCordonelInterface.UI
|
|
{
|
|
public partial class FrmRegisterStore : Form
|
|
{
|
|
private static readonly NLog.ILogger Logger = NLog.LogManager.GetLogger("GenesisCordonelInterface");
|
|
private readonly InterfaceToLaatzen interfaceToLaatzen = new InterfaceToLaatzen();
|
|
|
|
public class regStore
|
|
{
|
|
public String PcbId;
|
|
public DateTimeOffset created;
|
|
public List<regDefValue> keyValues;
|
|
}
|
|
|
|
public class regDefValue
|
|
{
|
|
public RegisterDefinition def;
|
|
public String value;
|
|
}
|
|
|
|
private readonly DataTable _dataTable = new DataTable();
|
|
private GenesisMeter _currentGenesis;
|
|
private MeterBatch _meterBatch = new MeterBatch();
|
|
private Color _defaultButtonColor;
|
|
private regStore _regsToStore;
|
|
private String _currentPcbId = "";
|
|
|
|
private Boolean IsBusy
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public FrmRegisterStore()
|
|
{
|
|
InitializeComponent();
|
|
|
|
//_dataTable = new DataTable();
|
|
_dataTable.Columns.Add("Name", typeof(String));
|
|
_dataTable.Columns.Add("Type", typeof(String));
|
|
|
|
_dataTable.Columns.Add("isChecked", typeof(Boolean));
|
|
_dataTable.Columns.Add("RawValue", typeof(String));
|
|
_dataTable.Columns.Add("RawValueFile", typeof(String));
|
|
_dataTable.Columns.Add("Value", typeof(String));
|
|
|
|
_dataTable.Columns.Add("Min", typeof(String));
|
|
_dataTable.Columns.Add("Max", typeof(String));
|
|
_dataTable.Columns.Add("Description", typeof(String));
|
|
|
|
_dataTable.Columns.Add("Version", typeof(String));
|
|
_dataTable.Columns.Add("IsAvailable", typeof(String));
|
|
|
|
_dataTable.Columns.Add("Privilege", typeof(String));
|
|
|
|
_dataTable.Columns.Add("btnHistoryText", typeof(String));
|
|
|
|
loadPreSet();
|
|
}
|
|
|
|
private void SetBusy(Boolean val, String action = "")
|
|
{
|
|
IsBusy = val;
|
|
if (IsBusy)
|
|
{
|
|
Invoke(new Action(() =>
|
|
{
|
|
probarBusy.Value = 0;
|
|
pnlBussy.Visible = true;
|
|
timProgress.Enabled = true;
|
|
lblAction.Text = action;
|
|
}));
|
|
}
|
|
else
|
|
{
|
|
ProgressTotal = null;
|
|
ProgressCurrent = null;
|
|
Invoke(new Action(() =>
|
|
{
|
|
pnlBussy.Visible = false;
|
|
timProgress.Enabled = false;
|
|
lblAction.Text = action;
|
|
lblProgress.Text = "";
|
|
}));
|
|
}
|
|
}
|
|
|
|
private void SetProgress(String text, Int32 total = 0, Int32 current = 0)
|
|
{
|
|
ProgressTotal = total;
|
|
ProgressCurrent = current;
|
|
Invoke(new Action(() => { lblProgress.Text = $@"{text} ({current}/{total})"; }));
|
|
}
|
|
|
|
private Int32? ProgressTotal;
|
|
private Int32? ProgressCurrent;
|
|
|
|
private void TimeProgress_tick(Object sender, EventArgs e)
|
|
{
|
|
if (IsBusy)
|
|
{
|
|
if (ProgressTotal.HasValue && ProgressCurrent.HasValue && !ProgressTotal.Value.Equals(0) &&
|
|
!ProgressCurrent.Value.Equals(0))
|
|
{
|
|
try
|
|
{
|
|
probarBusy.Value =
|
|
(Int32)Math.Round((ProgressCurrent.Value / (Double)ProgressTotal.Value) * 100,
|
|
0);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var current = probarBusy.Value;
|
|
if (current + 1 > 100)
|
|
{
|
|
current = 0;
|
|
}
|
|
|
|
probarBusy.Value = current + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void btnConnect_Click(Object sender, EventArgs e)
|
|
{
|
|
Connect();
|
|
}
|
|
|
|
private void btnRead_Click(Object sender, EventArgs e)
|
|
{
|
|
SetBusy(true, "Read Registers");
|
|
|
|
var hex = "4F793AF100000002";
|
|
var value = ulong.Parse(hex, NumberStyles.HexNumber);
|
|
|
|
Console.WriteLine(value);
|
|
|
|
|
|
Task.Factory.StartNew(() => { ReadRegisters(); }).ContinueWith(delegate
|
|
{
|
|
SetBusy(false);
|
|
});
|
|
}
|
|
|
|
|
|
private void btnStore_Click(Object sender, EventArgs e)
|
|
{
|
|
SetBusy(true, "Store to file");
|
|
Task.Factory.StartNew(() => { StoreFile(); }).ContinueWith(delegate
|
|
{
|
|
SetBusy(false);
|
|
});
|
|
}
|
|
|
|
private void btnFileToMeter_Click(Object sender, EventArgs e)
|
|
{
|
|
var openFileDialog = new OpenFileDialog();
|
|
openFileDialog.Filter = @"all JSON files (*.JSON)|*.JSON";
|
|
openFileDialog.Multiselect = false;
|
|
|
|
if (openFileDialog.ShowDialog() == DialogResult.OK)
|
|
{
|
|
SetBusy(true, "writing to meter");
|
|
|
|
var filename = openFileDialog.FileName;
|
|
|
|
Task.Factory.StartNew(() => { LoadFile(filename); }).ContinueWith(delegate
|
|
{
|
|
SetBusy(false);
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
private void registerGridView_CellEndEdit(Object sender, DataGridViewCellEventArgs e)
|
|
{
|
|
if (registerGridView.Columns[e.ColumnIndex].Name == "RawValue")
|
|
{
|
|
SetBusy(true, "writing register to meter");
|
|
|
|
Task.Factory.StartNew(() => { WriteRegister(e); }).ContinueWith(delegate
|
|
{
|
|
SetBusy(false);
|
|
});
|
|
|
|
}
|
|
}
|
|
|
|
private void WriteRegister(DataGridViewCellEventArgs e)
|
|
{
|
|
var inputValue = registerGridView.Rows[e.RowIndex].Cells[e.ColumnIndex].Value.ToString();
|
|
|
|
var arr = inputValue.Split('-');
|
|
var array = new Byte[arr.Length];
|
|
for (var i = arr.Length - 1; i >= 0; i--)
|
|
{
|
|
array[i] = Convert.ToByte(arr[i], 16);
|
|
}
|
|
|
|
var reg = (String)registerGridView.Rows[e.RowIndex].Cells[0].Value;
|
|
var meterRegisters = _currentGenesis.GetConfigRegistersDefinitions();
|
|
var regDef = meterRegisters.GetRegisterDefinitionByName(reg);
|
|
|
|
if (regDef.DataType != typeof(String) && regDef.DataType != typeof(ByteArray))
|
|
array = array.Reverse().ToArray();
|
|
_currentGenesis.WriteRegister(reg, array, checkRegister: true);
|
|
}
|
|
|
|
private void frmRegisterStore_Load(Object sender, EventArgs e)
|
|
{
|
|
_meterBatch = new MeterBatch();
|
|
|
|
var configFile = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), nameof(Xylem.Common.Hardware.WaterMeter.Genesis), ProgramConfig.SerialConfigFileName);
|
|
|
|
if (!File.Exists(configFile))
|
|
{
|
|
throw new ApplicationException($"Configuration file {configFile} not found ");
|
|
}
|
|
var tr = new StreamReader(configFile);
|
|
var meterConfigList = JsonConvert.DeserializeObject<SlotConfig[]>(tr.ReadToEnd());
|
|
cbComSlot.Items.Clear();
|
|
var listSlots = new List<Int32>();
|
|
if (listSlots == null) throw new ArgumentNullException(nameof(listSlots));
|
|
foreach (var item in meterConfigList)
|
|
{
|
|
cbComSlot.Items.Add(item.Slot);
|
|
listSlots.Add(item.Slot);
|
|
}
|
|
if (cbComSlot.Items.Count >= 1)
|
|
{
|
|
cbComSlot.SelectedItem = cbComSlot.Items[0];
|
|
}
|
|
|
|
var version = Assembly.GetExecutingAssembly().GetName().Version;
|
|
lblGtbVersion.Text = $@"GTB Version: {version.Major}.{version.Minor}.{version.Build}";
|
|
DisableAllButtons();
|
|
|
|
btnConnect.Enabled = true;
|
|
_defaultButtonColor = btnConnect.BackColor;
|
|
}
|
|
|
|
private void frmRegisterStore_FormClosing(Object sender, FormClosingEventArgs e)
|
|
{
|
|
_meterBatch.Dispose();
|
|
}
|
|
|
|
private void DisableAllButtons()
|
|
{
|
|
Invoke(new Action(() =>
|
|
{
|
|
btnConnect.Enabled = false;
|
|
btnReadRegister.Enabled = false;
|
|
|
|
btnRadioPressure.Enabled = false;
|
|
btnSetDefaultPulse.Enabled = false;
|
|
btnBatLife.Enabled = false;
|
|
btnBatteryIdle.Enabled = false;
|
|
btnCalibrationRestore.Enabled = false;
|
|
btnStoreAll.Enabled = false;
|
|
|
|
btnFileToRegister.Enabled = false;
|
|
btnRegisterToFile.Enabled = false;
|
|
|
|
btnReadFwVersions.Enabled = false;
|
|
|
|
btnReadRegister.BackColor = _defaultButtonColor;
|
|
|
|
btnRadioPressure.BackColor = _defaultButtonColor;
|
|
btnSetDefaultPulse.BackColor = _defaultButtonColor;
|
|
btnBatLife.BackColor = _defaultButtonColor;
|
|
btnBatteryIdle.BackColor = _defaultButtonColor;
|
|
btnCalibrationRestore.BackColor = _defaultButtonColor;
|
|
btnStoreAll.BackColor = _defaultButtonColor;
|
|
|
|
btnFileToRegister.BackColor = _defaultButtonColor;
|
|
btnRegisterToFile.BackColor = _defaultButtonColor;
|
|
|
|
btnReadFwVersions.BackColor = _defaultButtonColor;
|
|
|
|
}));
|
|
}
|
|
|
|
private void EnableAllButtons()
|
|
{
|
|
Invoke(new Action(() =>
|
|
{
|
|
btnConnect.Enabled = true;
|
|
btnReadRegister.Enabled = true;
|
|
|
|
btnRadioPressure.Enabled = true;
|
|
btnSetDefaultPulse.Enabled = true;
|
|
btnBatLife.Enabled = true;
|
|
btnBatteryIdle.Enabled = true;
|
|
btnCalibrationRestore.Enabled = true;
|
|
btnStoreAll.Enabled = true;
|
|
|
|
btnFileToRegister.Enabled = true;
|
|
btnRegisterToFile.Enabled = true;
|
|
|
|
btnReadFwVersions.Enabled = true;
|
|
}));
|
|
}
|
|
|
|
private void Connect()
|
|
{
|
|
try
|
|
{
|
|
if (string.IsNullOrEmpty(cbComSlot.SelectedItem.ToString()) ||
|
|
!int.TryParse(cbComSlot.SelectedItem.ToString(), out var slotNo))
|
|
{
|
|
return;
|
|
}
|
|
|
|
SetBusy(true, "Connect");
|
|
//disable all buttons
|
|
DisableAllButtons();
|
|
_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(slotNo);
|
|
_meterBatch.AddMeter(_currentGenesis);
|
|
|
|
Task.Factory.StartNew(() =>
|
|
{
|
|
_meterBatch.MetersLogin();
|
|
|
|
if (!_currentGenesis.IsLoggedOn && String.IsNullOrEmpty(_currentGenesis.PcbId))
|
|
{
|
|
SetBusy(false);
|
|
MessageBox.Show(@"ERROR: Cannot read out PcbId! Access to Cordonel denied!");
|
|
return;
|
|
}
|
|
|
|
Invoke(new Action(() =>
|
|
{
|
|
if (_currentGenesis.IsLoggedOn)
|
|
{
|
|
lblState.ForeColor = Color.Green;
|
|
lblState.Text = $@"Connected to PCB {_currentGenesis.PcbId}";
|
|
lblConfigVersion.Text = @"Configuration Version: " +
|
|
_currentGenesis.InterfaceInfo.InterfaceVersion;
|
|
lblConfigVersion.ForeColor =
|
|
_currentGenesis.InterfaceSupportsFwVersion ? Color.Green : Color.Red;
|
|
if (!_currentGenesis.InterfaceSupportsFwVersion)
|
|
{
|
|
var text = "CONFIGURATION OUTDATED!\n\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);
|
|
}
|
|
|
|
_dataTable.Rows.Clear();
|
|
|
|
foreach (var item in _currentGenesis.GetRegistersDic())
|
|
{
|
|
var row = _dataTable.NewRow();
|
|
row["Name"] = item.Key.GetIdent();
|
|
row["Type"] = item.Key.DataType.Name;
|
|
row["isChecked"] = false;
|
|
row["Value"] = "";
|
|
row["RawValue"] = item.Value;
|
|
row["RawValueFile"] = item.Value;
|
|
|
|
row["Min"] = item.Key.Minimum;
|
|
row["Max"] = item.Key.Maximum;
|
|
row["Description"] = item.Key.RegisterDetail.Description;
|
|
var From = item.Key.RegisterDetail.Version.First.HasValue
|
|
? item.Key.RegisterDetail.Version.First.Value.ToString()
|
|
: "-";
|
|
|
|
var To = item.Key.RegisterDetail.Version.Last.HasValue
|
|
? item.Key.RegisterDetail.Version.Last.Value.ToString()
|
|
: "-";
|
|
|
|
row["Version"] = $"from {From} to {To}";
|
|
row["IsAvailable"] = item.Key.IsAvailable;
|
|
row["Privilege"] = item.Key.RegisterDetail.Privilege.Lvl8.ToString();
|
|
row["btnHistoryText"] = "View History";
|
|
|
|
_dataTable.Rows.Add(row);
|
|
}
|
|
|
|
registerGridView.DataSource = _dataTable.DefaultView;
|
|
var column = registerGridView?.Columns["isChecked"];
|
|
if (column != null)
|
|
{
|
|
column.SortMode = DataGridViewColumnSortMode.Automatic;
|
|
registerGridView.Sort(column, ListSortDirection.Descending);
|
|
var viewColumn = registerGridView.Columns["RawValueFile"];
|
|
if (viewColumn != null) viewColumn.Visible = false;
|
|
|
|
}
|
|
|
|
column = registerGridView?.Columns["Name"];
|
|
if (column != null)
|
|
{
|
|
registerGridView.Sort(column, ListSortDirection.Ascending);
|
|
}
|
|
|
|
var btnHistory = new DataGridViewButtonColumn();
|
|
btnHistory.Name = "btnHistory";
|
|
|
|
btnHistory.DataPropertyName = "btnHistoryText";
|
|
registerGridView?.Columns.AddRange(btnHistory);
|
|
|
|
}
|
|
else
|
|
{
|
|
btnConnect.Enabled = false;
|
|
lblState.ForeColor = Color.Red;
|
|
lblState.Text = $@"Not Connected to PcbId:{_currentGenesis.PcbId}";
|
|
registerGridView.Visible = false;
|
|
}
|
|
}));
|
|
}).ContinueWith(delegate
|
|
{
|
|
SetBusy(false);
|
|
EnableAllButtons();
|
|
});
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
SetBusy(false);
|
|
MessageBox.Show(ex.Message, @"FAILED", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
// Dispose meter
|
|
_meterBatch.RemoveAllMeters();
|
|
// If meter is not already assigned to batch as the config reader may fail
|
|
_currentGenesis?.DisposeMeter();
|
|
|
|
btnConnect.Enabled = true;
|
|
}
|
|
}
|
|
|
|
private async void __Connect()
|
|
{
|
|
try
|
|
{
|
|
if (cbComSlot.SelectedItem == null ||
|
|
string.IsNullOrEmpty(cbComSlot.SelectedItem.ToString()) ||
|
|
!int.TryParse(cbComSlot.SelectedItem.ToString(), out var slotNo))
|
|
{
|
|
return;
|
|
}
|
|
|
|
SetBusy(true, "Connect");
|
|
DisableAllButtons();
|
|
_dataTable.Rows.Clear();
|
|
|
|
var result = await Task.Run(() => interfaceToLaatzen.Connect(slotNo, cbxUseOfflinePwds.Checked));
|
|
|
|
if (result.Success)
|
|
{
|
|
lblState.ForeColor = Color.Green;
|
|
lblState.Text = $@"Connected to PCB {result.PcbId}";
|
|
lblConfigVersion.Text = @"Configuration Version: " + result.InterfaceVersion;
|
|
lblConfigVersion.ForeColor = result.InterfaceSupportsFwVersion ? Color.Green : Color.Red;
|
|
|
|
if (!result.InterfaceSupportsFwVersion)
|
|
{
|
|
var text = "CONFIGURATION OUTDATED!\n\n" +
|
|
"The loaded \"configuration.json\" " +
|
|
$"version: {result.InterfaceVersion}\n" +
|
|
$"does NOT support the Cordonel FW version: {result.FwVersion}!";
|
|
|
|
MessageBox.Show(text, @"FAILED", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
|
|
foreach (var item in result.Registers)
|
|
{
|
|
var row = _dataTable.NewRow();
|
|
row["Name"] = item.Name;
|
|
row["Type"] = item.Type;
|
|
row["isChecked"] = false;
|
|
row["Value"] = "";
|
|
row["RawValue"] = item.RawValue;
|
|
row["RawValueFile"] = item.RawValue;
|
|
row["Min"] = item.Min;
|
|
row["Max"] = item.Max;
|
|
row["Description"] = item.Description;
|
|
row["Version"] = item.Version;
|
|
row["IsAvailable"] = item.IsAvailable;
|
|
row["Privilege"] = item.Privilege;
|
|
row["btnHistoryText"] = "View History";
|
|
|
|
_dataTable.Rows.Add(row);
|
|
}
|
|
|
|
registerGridView.DataSource = _dataTable.DefaultView;
|
|
|
|
var column = registerGridView?.Columns["isChecked"];
|
|
if (column != null)
|
|
{
|
|
column.SortMode = DataGridViewColumnSortMode.Automatic;
|
|
registerGridView.Sort(column, ListSortDirection.Descending);
|
|
|
|
var viewColumn = registerGridView.Columns["RawValueFile"];
|
|
if (viewColumn != null)
|
|
viewColumn.Visible = false;
|
|
}
|
|
|
|
column = registerGridView?.Columns["Name"];
|
|
if (column != null)
|
|
{
|
|
registerGridView.Sort(column, ListSortDirection.Ascending);
|
|
}
|
|
|
|
if (registerGridView.Columns["btnHistory"] == null)
|
|
{
|
|
var btnHistory = new DataGridViewButtonColumn
|
|
{
|
|
Name = "btnHistory",
|
|
DataPropertyName = "btnHistoryText"
|
|
};
|
|
|
|
registerGridView.Columns.Add(btnHistory);
|
|
}
|
|
|
|
registerGridView.Visible = true;
|
|
btnConnect.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
btnConnect.Enabled = false;
|
|
lblState.ForeColor = Color.Red;
|
|
lblState.Text = $@"Not Connected to PcbId:{result.PcbId}";
|
|
registerGridView.Visible = false;
|
|
|
|
MessageBox.Show(result.ErrorMessage ?? "Connect failed.", @"FAILED", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, @"FAILED", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
btnConnect.Enabled = true;
|
|
}
|
|
finally
|
|
{
|
|
SetBusy(false);
|
|
EnableAllButtons();
|
|
}
|
|
}
|
|
|
|
private void GetPcbId(Int32 slotNR)
|
|
{
|
|
try
|
|
{
|
|
_meterBatch.RemoveAllMeters();
|
|
_currentGenesis = new GenesisMeter();
|
|
try
|
|
{
|
|
_currentGenesis.SetupFromConfigFile(slotNR);
|
|
_meterBatch.AddMeter(_currentGenesis);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.Error(ex, $"Slot #{slotNR} failed: {ex.Message}");
|
|
}
|
|
|
|
_currentPcbId = _currentGenesis.GetPcbId();
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.Error(ex, ex.Message);
|
|
}
|
|
|
|
_currentGenesis.Dispose();
|
|
_currentGenesis = null;
|
|
}
|
|
|
|
private void SelectPreset(String content)
|
|
{
|
|
foreach (var rowItem in _dataTable.Rows)
|
|
{
|
|
if (rowItem is DataRow)
|
|
{
|
|
((DataRow)rowItem)["isChecked"] = false;
|
|
}
|
|
}
|
|
|
|
|
|
switch (content)
|
|
{
|
|
case "All":
|
|
foreach (var rowItem in _dataTable.Rows)
|
|
{
|
|
if (rowItem is DataRow)
|
|
{
|
|
((DataRow)rowItem)["isChecked"] = true;
|
|
}
|
|
}
|
|
|
|
break;
|
|
case "Ampl. Test":
|
|
foreach (var rowItem in _dataTable.Rows)
|
|
{
|
|
if (rowItem is DataRow)
|
|
{
|
|
if (preSetAmplTest.Any(p => p.Equals(((DataRow)rowItem)["Name"].ToString())))
|
|
{
|
|
((DataRow)rowItem)["isChecked"] = true;
|
|
}
|
|
else
|
|
{
|
|
((DataRow)rowItem)["isChecked"] = false;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
break;
|
|
case "Temp. Calibration":
|
|
foreach (var rowItem in _dataTable.Rows)
|
|
{
|
|
if (rowItem is DataRow)
|
|
{
|
|
if (preSetTempCal.Any(p => p.Equals(((DataRow)rowItem)["Name"].ToString())))
|
|
{
|
|
((DataRow)rowItem)["isChecked"] = true;
|
|
}
|
|
else
|
|
{
|
|
((DataRow)rowItem)["isChecked"] = false;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
break;
|
|
case "Zero Flow":
|
|
foreach (var rowItem in _dataTable.Rows)
|
|
{
|
|
if (rowItem is DataRow)
|
|
{
|
|
if (preSetZeroFlow.Any(p => p.Equals(((DataRow)rowItem)["Name"].ToString())))
|
|
{
|
|
((DataRow)rowItem)["isChecked"] = true;
|
|
}
|
|
else
|
|
{
|
|
((DataRow)rowItem)["isChecked"] = false;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
break;
|
|
case "Flow Calibration":
|
|
foreach (var rowItem in _dataTable.Rows)
|
|
{
|
|
if (rowItem is DataRow)
|
|
{
|
|
if (preSetFlowCalibration.Any(p => p.Equals(((DataRow)rowItem)["Name"].ToString())))
|
|
{
|
|
((DataRow)rowItem)["isChecked"] = true;
|
|
}
|
|
else
|
|
{
|
|
((DataRow)rowItem)["isChecked"] = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
case "All Meteorological":
|
|
foreach (var rowItem in _dataTable.Rows)
|
|
{
|
|
if (rowItem is DataRow)
|
|
{
|
|
if (preSetAllMeteorological.Any(p => p.Equals(((DataRow)rowItem)["Name"].ToString())))
|
|
{
|
|
((DataRow)rowItem)["isChecked"] = true;
|
|
}
|
|
else
|
|
{
|
|
((DataRow)rowItem)["isChecked"] = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
case "Own":
|
|
case "None":
|
|
foreach (var rowItem in _dataTable.Rows)
|
|
{
|
|
if (rowItem is DataRow)
|
|
{
|
|
((DataRow)rowItem)["isChecked"] = false;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
public class RegisterRestoreData
|
|
{
|
|
public Int32 PcbID { get; set; }
|
|
public DateTime BuildTime { get; set; }
|
|
public Dictionary<String, Byte[]> RegisterList { get; set; }
|
|
|
|
}
|
|
|
|
private RegisterRestoreData ReadRegisters()
|
|
{
|
|
|
|
if (_currentGenesis != null)
|
|
{
|
|
_regsToStore = new regStore
|
|
{
|
|
PcbId = _currentGenesis.PcbId,
|
|
created = DateTimeOffset.Now,
|
|
keyValues = new List<regDefValue>()
|
|
};
|
|
|
|
var ret = new RegisterRestoreData
|
|
{
|
|
PcbID = int.Parse(_currentGenesis.PcbId),
|
|
BuildTime = DateTime.Now,
|
|
RegisterList = new Dictionary<String, Byte[]>()
|
|
};
|
|
|
|
var total = 0;
|
|
foreach (var rowItem in _dataTable.Rows)
|
|
{
|
|
if (rowItem is DataRow)
|
|
{
|
|
if ((Boolean)((DataRow)rowItem)["isChecked"])
|
|
{
|
|
total += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
var done = 0;
|
|
foreach (var rowItem in _dataTable.Rows)
|
|
{
|
|
if (rowItem is DataRow)
|
|
{
|
|
if ((Boolean)((DataRow)rowItem)["isChecked"])
|
|
{
|
|
|
|
var reg = ((DataRow)rowItem)["Name"].ToString();
|
|
|
|
var meterRegisters = _currentGenesis.GetConfigRegistersDefinitions();
|
|
var regDef = meterRegisters.GetRegisterDefinitionByName(reg);
|
|
SetProgress($"Read Register {regDef.RegisterName}", total, done + 1);
|
|
if (regDef.RegisterDetail != null && (
|
|
regDef.RegisterDetail.Privilege.Lvl8 == Access.RO ||
|
|
regDef.RegisterDetail.Privilege.Lvl8 == Access.RW))
|
|
{
|
|
try
|
|
{
|
|
var rawRegister = _currentGenesis.ReadRegister(reg);
|
|
ret.RegisterList[reg] = rawRegister;
|
|
|
|
//var temp = RegisterConverter.GetRegisterContent(regDef, rawRegister);
|
|
((DataRow)rowItem)["RawValue"] = RegisterConverter.GetRegisterRawText(regDef, rawRegister);
|
|
_regsToStore.keyValues.Add(new regDefValue
|
|
{
|
|
def = regDef,
|
|
value = BitConverter.ToString(rawRegister)
|
|
});
|
|
|
|
try
|
|
{
|
|
var result = RegisterConverter.ConvertToText(rawRegister, regDef.DataType);
|
|
((DataRow)rowItem)["Value"] = result;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
((DataRow)rowItem)["Value"] = "not converted";
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
((DataRow)rowItem)["Value"] = "error";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
((DataRow)rowItem)["RawValue"] = "No Access";
|
|
((DataRow)rowItem)["Value"] = "";
|
|
}
|
|
|
|
done += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private void CompareFile(String filename)
|
|
{
|
|
|
|
var styleDiff = new DataGridViewCellStyle
|
|
{
|
|
BackColor = Color.Red,
|
|
ForeColor = Color.Black
|
|
};
|
|
|
|
var styleEqual = new DataGridViewCellStyle
|
|
{
|
|
BackColor = Color.Green,
|
|
ForeColor = Color.Black
|
|
};
|
|
|
|
SetProgress($"Read File {filename}");
|
|
var text = File.ReadAllText(filename);
|
|
var loadedRegStore = JsonConvert.DeserializeObject<regStore>(text);
|
|
|
|
var done = 1;
|
|
|
|
foreach (var rowItem in _dataTable.Rows)
|
|
{
|
|
if (rowItem is DataRow)
|
|
{
|
|
|
|
SetProgress("Read file", loadedRegStore.keyValues.Count, done);
|
|
|
|
var reg = ((DataRow)rowItem)["Name"].ToString();
|
|
var meterRegisters = _currentGenesis.GetConfigRegistersDefinitions();
|
|
var regDef = meterRegisters.GetRegisterDefinitionByName(reg);
|
|
|
|
var keyValue =
|
|
loadedRegStore.keyValues.FirstOrDefault(f => f.def.RegisterName.Equals(regDef.RegisterName));
|
|
if (keyValue != null)
|
|
{
|
|
((DataRow)rowItem)["RawValueFile"] = keyValue.value;
|
|
|
|
if (regDef.RegisterDetail.Privilege.Lvl8 == Access.RO ||
|
|
regDef.RegisterDetail.Privilege.Lvl8 == Access.RW)
|
|
{
|
|
var rawRegister = _currentGenesis.ReadRegister(reg);
|
|
|
|
//var temp = RegisterConverter.GetRegisterContent(regDef, rawRegister);
|
|
((DataRow)rowItem)["RawValue"] = RegisterConverter.GetRegisterRawText(regDef, rawRegister);
|
|
_regsToStore.keyValues.Add(new regDefValue
|
|
{
|
|
def = regDef,
|
|
value = BitConverter.ToString(rawRegister)
|
|
});
|
|
|
|
try
|
|
{
|
|
var result = RegisterConverter.ConvertToText(rawRegister, regDef.DataType);
|
|
((DataRow)rowItem)["Value"] = result;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
((DataRow)rowItem)["Value"] = "not converted";
|
|
}
|
|
|
|
|
|
DataGridViewCell meterCell = null;
|
|
DataGridViewCell fileCell = null;
|
|
foreach (DataGridViewRow row in registerGridView.Rows)
|
|
{
|
|
if (row.Cells["Name"].Value.Equals(regDef.RegisterName))
|
|
{
|
|
meterCell = row.Cells["RawValue"];
|
|
fileCell = row.Cells["RawValueFile"];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (meterCell != null && fileCell != null)
|
|
{
|
|
if (BitConverter.ToString(rawRegister).Equals(keyValue.value))
|
|
{
|
|
|
|
meterCell.Style = styleEqual;
|
|
fileCell.Style = styleEqual;
|
|
}
|
|
else
|
|
{
|
|
meterCell.Style = styleDiff;
|
|
fileCell.Style = styleDiff;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
((DataRow)rowItem)["RawValue"] = "No Access";
|
|
((DataRow)rowItem)["Value"] = "";
|
|
}
|
|
|
|
done += 1;
|
|
}
|
|
else
|
|
{
|
|
((DataRow)rowItem)["RawValueFile"] = "Not in File";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ShowFile(String filename)
|
|
{
|
|
SetProgress($"Read File {filename}");
|
|
var text = File.ReadAllText(filename);
|
|
var loadedRegStore = JsonConvert.DeserializeObject<regStore>(text);
|
|
|
|
var done = 1;
|
|
|
|
foreach (var rowItem in _dataTable.Rows)
|
|
{
|
|
if (rowItem is DataRow)
|
|
{
|
|
|
|
SetProgress("Compare file", loadedRegStore.keyValues.Count, done);
|
|
var regDef = (RegisterDefinition)((DataRow)rowItem)["regDef"];
|
|
var keyValue =
|
|
loadedRegStore.keyValues.FirstOrDefault(f => f.def.RegisterName.Equals(regDef.RegisterName));
|
|
if (keyValue != null)
|
|
{
|
|
((DataRow)rowItem)["RawValueFile"] = keyValue.value;
|
|
|
|
}
|
|
else
|
|
{
|
|
((DataRow)rowItem)["RawValueFile"] = "Not in File";
|
|
}
|
|
|
|
done += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void LoadFile(String filename)
|
|
{
|
|
//SetProgreess($"Read File {filename}");
|
|
//var text = File.ReadAllText(filename);
|
|
//var loadedRegStore = Newtonsoft.Json.JsonConvert.DeserializeObject<regStore>(text);
|
|
//if (loadedRegStore.PcbId != _currentPcbId)
|
|
//{
|
|
// MessageBox.Show($"Please connect to PCB {loadedRegStore.PcbId}");
|
|
// return;
|
|
//}
|
|
|
|
//var done = 1;
|
|
//foreach (var keyValueToWrite in loadedRegStore.keyValues)
|
|
//{
|
|
// SetProgreess($"Write Register {keyValueToWrite.def.Name}", loadedRegStore.keyValues.Count, done);
|
|
// var valueToWrite = keyValueToWrite.value.Split('-').Select(b => Convert.ToByte(b, 16));
|
|
// valueToWrite.Reverse();
|
|
// _currentGenesis.WriteRegister(keyValueToWrite.def, valueToWrite.ToArray());
|
|
|
|
// done = done + 1;
|
|
//}
|
|
|
|
//read();
|
|
}
|
|
|
|
private void StoreFile()
|
|
{
|
|
//read();
|
|
//var text = Newtonsoft.Json.JsonConvert.SerializeObject(regsToStore);
|
|
//SaveFileDialog saveFileDialog = new SaveFileDialog();
|
|
//saveFileDialog.FileName = $"storePcbId{regsToStore.PcbId}on{regsToStore.created.ToString("yyyyMMdd")}.json";
|
|
|
|
//Invoke(new Action(() =>
|
|
//{
|
|
|
|
// if (saveFileDialog.ShowDialog() == DialogResult.OK)
|
|
// File.WriteAllText(saveFileDialog.FileName, text);
|
|
|
|
//}));
|
|
|
|
//var done = 1;
|
|
//foreach (var keyValueToWrite in regsToStore.keyValues)
|
|
//{
|
|
// SetProgreess($"Write Register {keyValueToWrite.def.Name}", regsToStore.keyValues.Count, done);
|
|
// var valueToWrite = keyValueToWrite.value.Split('-').Select(b => Convert.ToByte(b, 16));
|
|
// valueToWrite.Reverse();
|
|
// _currentGenesis.WriteRegister(keyValueToWrite.def, valueToWrite.ToArray());
|
|
|
|
// done = done + 1;
|
|
//}
|
|
|
|
}
|
|
|
|
private void StoreAsCsv()
|
|
{
|
|
ReadRegisters();
|
|
|
|
var csv = new StringBuilder();
|
|
var saveFileDialog = new SaveFileDialog();
|
|
saveFileDialog.FileName = $"storePcbId{_regsToStore.PcbId}on{_regsToStore.created.ToString("yyyyMMdd")}.csv";
|
|
|
|
csv.AppendLine("name;value");
|
|
foreach (var values in _regsToStore.keyValues)
|
|
{
|
|
csv.AppendLine($"{values.def.RegisterName};{values.value}");
|
|
}
|
|
|
|
Invoke(new Action(() =>
|
|
{
|
|
|
|
if (saveFileDialog.ShowDialog() == DialogResult.OK)
|
|
{
|
|
File.WriteAllText(saveFileDialog.FileName, csv.ToString());
|
|
}
|
|
}));
|
|
}
|
|
|
|
private List<String> preSetAmplTest = new List<String>();
|
|
private List<String> preSetTempCal = new List<String>();
|
|
private List<String> preSetZeroFlow = new List<String>();
|
|
private List<String> preSetFlowCalibration = new List<String>();
|
|
private List<String> preSetAllMeteorological = new List<String>();
|
|
private List<String> preSetDefault = new List<String>();
|
|
private void loadPreSet()
|
|
{
|
|
#region defaults
|
|
preSetDefault.Add(Register.Genesisflow.SampleRate);
|
|
preSetDefault.Add(Register.Genesisflow.LedMode);
|
|
preSetDefault.Add(Register.Genesisflow.MeterSize);
|
|
#endregion
|
|
|
|
#region preSetAmplTest
|
|
|
|
preSetAmplTest.Add(Register.Genesisflow.FirstHitUpdatePeriod);
|
|
preSetAmplTest.Add(Register.Genesisflow.FirstHitShift);
|
|
preSetAmplTest.Add(Register.Genesisflow.FirstHitPercent1);
|
|
preSetAmplTest.Add(Register.Genesisflow.FirstHitPercent2);
|
|
preSetAmplTest.Add(Register.Genesisflow.FirstHitPercent3);
|
|
|
|
#endregion
|
|
|
|
#region preSetTempCal
|
|
|
|
preSetTempCal.Add(Register.Genesisflow.ToFTempCalibrate);
|
|
preSetTempCal.Add(Register.Genesisflow.ToFTempOffset1);
|
|
preSetTempCal.Add(Register.Genesisflow.ToFTempOffset2);
|
|
preSetTempCal.Add(Register.Genesisflow.ToFTempOffset3);
|
|
|
|
#endregion
|
|
|
|
#region preSetZeroFlow
|
|
|
|
preSetZeroFlow.Add(Register.Genesisflow.ZeroOffset1);
|
|
preSetZeroFlow.Add(Register.Genesisflow.ZeroOffset2);
|
|
preSetZeroFlow.Add(Register.Genesisflow.ZeroOffset3);
|
|
|
|
#endregion
|
|
|
|
#region preSetAllMeteorological
|
|
|
|
preSetFlowCalibration.Add(Register.Genesisflow.CalFactor1);
|
|
preSetFlowCalibration.Add(Register.Genesisflow.CalFactor2);
|
|
preSetFlowCalibration.Add(Register.Genesisflow.CalFactor3);
|
|
|
|
#endregion
|
|
|
|
#region preset All metro
|
|
|
|
preSetAllMeteorological.AddRange(preSetAmplTest);
|
|
preSetAllMeteorological.AddRange(preSetTempCal);
|
|
preSetAllMeteorological.AddRange(preSetZeroFlow);
|
|
preSetAllMeteorological.AddRange(preSetFlowCalibration);
|
|
|
|
#endregion
|
|
|
|
#region addDefaults
|
|
|
|
preSetAllMeteorological.AddRange(preSetDefault);
|
|
preSetZeroFlow.AddRange(preSetDefault);
|
|
preSetFlowCalibration.AddRange(preSetDefault);
|
|
preSetTempCal.AddRange(preSetDefault);
|
|
preSetAmplTest.AddRange(preSetDefault);
|
|
|
|
#endregion
|
|
}
|
|
|
|
private void btnGetPCbID_Click(Object sender, EventArgs e)
|
|
{
|
|
Logger.Trace("UI-CLICK: FrmRegisterStore: btnGetPCbID_Click() use APILaatzen");
|
|
|
|
if (cbComSlot.SelectedItem != null) // && cbComSlot.SelectedValue is ListBoxItem)
|
|
{
|
|
_currentPcbId = "";
|
|
if (!string.IsNullOrEmpty(cbComSlot.SelectedItem.ToString()) &&
|
|
int.TryParse(cbComSlot.SelectedItem.ToString(), out var slotNR))
|
|
{
|
|
|
|
SetBusy(true, "GetPcbId");
|
|
|
|
// as new meter object will be generated the data grid shows outdated data
|
|
_dataTable.Rows.Clear();
|
|
DisableAllButtons();
|
|
|
|
Task.Factory.StartNew(() => { GetPcbId(slotNR); }).ContinueWith(delegate
|
|
{
|
|
Invoke(new Action(() =>
|
|
{
|
|
SetBusy(false);
|
|
btnConnect.Enabled = true;
|
|
MessageBox.Show(_currentPcbId);
|
|
}));
|
|
});
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
private async void __btnGetPCbID_Click(object sender, EventArgs e)
|
|
{
|
|
Logger.Trace("UI-CLICK: FrmRegisterStore: btnGetPCbID_Click() use API2");
|
|
|
|
if (cbComSlot.SelectedItem == null)
|
|
return;
|
|
|
|
if (!int.TryParse(cbComSlot.SelectedItem.ToString(), out var slotNr))
|
|
return;
|
|
|
|
try
|
|
{
|
|
_currentPcbId = "";
|
|
|
|
SetBusy(true, "GetPcbId");
|
|
|
|
// as new meter object will be generated the data grid shows outdated data
|
|
_dataTable.Rows.Clear();
|
|
DisableAllButtons();
|
|
|
|
_currentPcbId = await Task.Run(() => interfaceToLaatzen.GetPcbId(slotNr));
|
|
|
|
btnConnect.Enabled = true;
|
|
|
|
Logger.Info("COM: Request detection SUCCESS for slot " + slotNr);
|
|
|
|
MessageBox.Show(_currentPcbId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
|
|
Logger.Error("COM: Request detection FAILED for slot " + slotNr);
|
|
}
|
|
finally
|
|
{
|
|
SetBusy(false);
|
|
}
|
|
}
|
|
|
|
private void btnReadFwVersions_Click(Object sender, EventArgs e)
|
|
{
|
|
if (_currentGenesis != null)
|
|
{
|
|
var sb = new StringBuilder();
|
|
sb.AppendLine($"PCBID: {_currentGenesis.PcbId}");
|
|
sb.AppendLine($"Date: {DateTimeOffset.UtcNow}");
|
|
sb.AppendLine($"System Core Revision: {_currentGenesis.StrCoreRevision}");
|
|
foreach (var fm in _currentGenesis.MeterAppListVersion.OrderBy(o => o.AppId))
|
|
{
|
|
var versionString = fm.IsInstalled
|
|
? $"V: {fm.StrVersion} - CRC: 0x{fm.Crc:X4}" : "Not installed";
|
|
if (fm.Status == MeterAppState.Unknown)
|
|
versionString = "Communication error";
|
|
|
|
sb.AppendLine($"AppId: 0x{fm.AppId:X2} - {versionString} - AppName: {fm.AppName}");
|
|
}
|
|
|
|
MessageBox.Show(sb.ToString());
|
|
}
|
|
}
|
|
|
|
private void btnProgram_Click(Object sender, EventArgs e)
|
|
{
|
|
if (_currentGenesis != null)
|
|
{
|
|
var fa = new List<Byte>();
|
|
fa.AddRange((new Byte[] { 0x0E, 0x9F, 0xAC, 0xC6 }));
|
|
fa.AddRange((new Byte[] { 0xA0, 0xE1, 0xEF, 0x1C }));
|
|
fa.AddRange((new Byte[] { 0x3B, 0x27, 0xA4, 0x9B }));
|
|
fa.AddRange((new Byte[] { 0xAC, 0x21, 0x65, 0x35 }));
|
|
_currentGenesis.ReLogin();
|
|
_currentGenesis.WriteRegister("SENSUSRADIO_EncryptionKey", fa.ToArray());
|
|
//var before = _currentGenesis.ReadRegister("SYSTEM_CalendarSeconds");
|
|
|
|
//var tsa = DateTimeOffset.UtcNow - new DateTimeOffset(2000, 1, 1, 0, 0, 0, new TimeSpan(0));
|
|
//_currentGenesis.WriteRegister("SYSTEM_CalendarSeconds", Convert.ToInt32(tsa.TotalSeconds));
|
|
|
|
//var after = _currentGenesis.ReadRegister("SYSTEM_CalendarSeconds");
|
|
|
|
|
|
|
|
|
|
//#region fixparameter
|
|
|
|
//register final programming
|
|
|
|
//var overAllResult = new List<Tuple<String, Boolean>>();
|
|
////611.219.280
|
|
////
|
|
//var ts = DateTimeOffset.UtcNow - new DateTimeOffset(2000, 1, 1, 0, 0, 0, new TimeSpan(0));
|
|
|
|
|
|
|
|
|
|
////Alarms
|
|
//////_currentGenesis.WriteRegister("SENSUSRADIO_MainAlarmMask?
|
|
//////_currentGenesis.WriteRegister("SENSUSRADIO_ExtendedAlarmMask ?
|
|
////CUSTOMER_AlarmBroadcastMask?
|
|
////CUSTOMER_AlarmEnableMask ?
|
|
////CUSTOMER_AlarmVisualAutoClearMask?
|
|
////CUSTOMER_AlarmVisualMask ?
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_SealDisplay",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
|
|
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("SYSTEM_CalendarSeconds",
|
|
// Convert.ToInt32(ts.TotalSeconds), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_ExcessFlowTimeThreshold",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x05 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_ExcessFlowVolumeThreshold",
|
|
// (new Byte[] { 0x00, 0x00, 0x61, 0xA8 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_LeakFlowThreshold",
|
|
// (new Byte[] { 0x00, 0x00, 0x01, 0x77 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_LeakTimeThreshold",
|
|
// (new Byte[] { 0x00, 0x00, 0x4E, 0xC0 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_Locale",
|
|
// (new Byte[] { 0x00, 0x00, 0x01, 0x60 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_PressureHighDelay",
|
|
// (new Byte[] { 0x00, 0x00, 0x02, 0x58 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_PressureHighThreshold",
|
|
// (new Byte[] { 0x00, 0x0B, 0x71, 0xB0 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_PressureLowDelay",
|
|
// (new Byte[] { 0x00, 0x00, 0x02, 0x58 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_PressureLowThreshold",
|
|
// (new Byte[] { 0x00, 0x00, 0x75, 0x30 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_ReverseFlowTimeThreshold",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x78 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_TemperatureHighDelay",
|
|
// (new Byte[] { 0x00, 0x00, 0x01, 0x2C }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_TemperatureHighThreshold",
|
|
// (new Byte[] { 0x00, 0x00, 0x01, 0xF4 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_TemperatureLowDelay",
|
|
// (new Byte[] { 0x00, 0x00, 0x01, 0x2C }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_TemperatureLowThreshold",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x14 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_ArrowThreshold",
|
|
// (new Byte[] { 0x00, 0x1E, 0x84, 0x80 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_DisplayPow10",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0xFD }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_DisplayUnits",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_ForwardArrow",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_HardErrorLimit",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x04 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_LedMode",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
|
|
////overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_LowFlowMaxPeriod", (new Byte[] { 0x00, 0x00, 0x00, 0x3C }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_LowFlowMaxPeriod", 60 << 16, true, true));
|
|
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_LowFlowThreshold",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0xC8 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_MeterSize",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x01 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_PipeFillingDelay",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x1E }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_ResetAccumulators",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x01 }).Reverse().ToArray(), true, false));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_SampleRate",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x02 }).Reverse().ToArray(), true, true));
|
|
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_UpdateThreshold",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("IRDA_AdapterPresenceLimit",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x60 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("IRDA_PulseReportRate",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_FlowPoint",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x02 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_FlowUnits",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x04 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_PressureOffset",
|
|
// (new Byte[] { 0x00, 0x00, 0x03, 0xF5 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_PressurePresent",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_PressureRate",
|
|
// (new Byte[] { 0x00, 0x0D, 0xBB, 0xA0 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_PressureUnits",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_PulseLength",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x07 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_PulseMode",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x01 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_PulseWeight",
|
|
// (new Byte[] { 0x00, 0x00, 0x27, 0x10 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_TemperatureUnits",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("PERIODICLOG_AverageFlowPeriod",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x05 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("PERIODICLOG_DataLogContents",
|
|
// (new Byte[] { 0x08, 0x00, 0x24, 0x03 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("PERIODICLOG_DataLogPeriod",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x3C }).Reverse().ToArray(), true, false));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("PERIODICLOG_FixedDateDayOfMonth",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x01 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("PERIODICLOG_FixedDateReadingContents",
|
|
// (new Byte[] { 0x08, 0x00, 0x24, 0x03 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("PERIODICLOG_PeriodicLogLifeTimeCounter",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x0 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("PERIODICLOG_ResetCounter",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x0 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("POWERMON_BatterySelection",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, false));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("POWERMON_WarnFromClamp",
|
|
// (new Byte[] { 0x00, 0x01, 0x51, 0x80 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_WakeupInterval",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x03 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_MbusState",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x07 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_UtcTimeOffset",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
|
|
|
|
//// just read later //overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_FrequencyIndicator}).Reverse(), true, true);
|
|
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_HistoricalAlarmsDays",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x1D }).Reverse().ToArray(), true, true));
|
|
|
|
|
|
////Original
|
|
////0x11, 0x12, 0x13, 0x14, 0x21, 0x22, 0x23, 0x24, 0x31, 0x32, 0x33, 0x34, 0x41, 0x42, 0x43, 0x44
|
|
////Write to register
|
|
////0x14, 0x13, 0x12, 0x11, 0x24, 0x23, 0x22, 0x21, 0x34, 0x33, 0x32, 0x31, 0x44, 0x43, 0x42, 0x41
|
|
|
|
|
|
////good one
|
|
////E6-C8-88-00-DE-B8-68-C0-D6-A8-48-80-CE-98-28-40
|
|
////0E-05-04-04-00-14-30-68-D0-14-0E-80-40-63-93-73-22
|
|
|
|
////&bad one
|
|
////0E-05-04-05-00-00-88-C8-E6-C0-68-B8-DE-80-48-A8-D6-40-28-98-CE
|
|
|
|
|
|
////0E-05-04-04-00-22-73-93-63-40-80-0E-14-D0-68-30-14
|
|
|
|
//var funkadresse = new List<Byte>();
|
|
//funkadresse.AddRange((new Byte[] { 0xE6, 0xC8, 0x88, 0x00 }).ToArray());
|
|
//funkadresse.AddRange((new Byte[] { 0xDE, 0xB8, 0x68, 0xC0 }).ToArray());
|
|
//funkadresse.AddRange((new Byte[] { 0xD6, 0xA8, 0x48, 0x80 }).ToArray());
|
|
//funkadresse.AddRange((new Byte[] { 0xCE, 0x98, 0x28, 0x40 }).ToArray());
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_EncryptionKey", funkadresse.ToArray(),
|
|
// true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_EncryptionKey",
|
|
// (new Byte[]
|
|
// {
|
|
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
// }).ToArray(), true, true));
|
|
////overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_Authentification", (new Byte[] { 0x14, 0x30, 0x68, 0xD0, 0x14, 0x0E, 0x80, 0x40, 0x63, 0x93, 0x73, 0x22 }).ToArray(), true, true));
|
|
////overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_Authentification", (new Byte[]
|
|
////{
|
|
//// 0xD0,0x68 , 0x30 ,0x14,
|
|
//// 0x40,0x80, 0x0E ,0x14,
|
|
//// 0x22, 0x73, 0x93,0x63
|
|
////}).ToArray(), true, true));
|
|
//////E6C88800DEB868C0D6A84880CE982840
|
|
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_CustomerText",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
|
|
|
|
//using (var dataacces =
|
|
// new SqlDataAccess(
|
|
// "Data Source=SLASQL01;;Initial Catalog=Auftrag;Persist Security Info=False;User ID=GenesisPasswordService;Password=PcbID;")
|
|
//)
|
|
//{
|
|
|
|
// var sb = new StringBuilder();
|
|
// sb.AppendLine(
|
|
// $" SELECT distinct [MapPcbIdToSerialNumber_SerialNumber],Adresse,FunkschluesselIndex,SENSUSRADIO_PowerLevel, SENSUSRADIO_PowerLevelOption, SENSUSRADIO_ImpedanceCodeNew,SENSUSRADIO_ImpedanceCodeOption ");
|
|
// sb.AppendLine($" FROM [Auftrag].[dbo].[MapPcbIdToSerialNumber] pcb ");
|
|
// sb.AppendLine(
|
|
// $" inner join tmpRadioConfig radio on radio.pcbID = pcb.MapPcbIdToSerialNumber_PcbId");
|
|
// sb.AppendLine(
|
|
// $" inner join Genesis_Meter meter on meter.Seriennummer = pcb.MapPcbIdToSerialNumber_SerialNumber");
|
|
// sb.AppendLine($" where [MapPcbIdToSerialNumber_PcbId] = '{_currentGenesis.GetPcbId()}'");
|
|
|
|
// var MapData = dataacces.ExecuteQuery(sb.ToString());
|
|
// if (MapData.Rows.Count != 1)
|
|
// {
|
|
// MessageBox.Show("Faild to get order data");
|
|
// return;
|
|
// }
|
|
|
|
// var SENSUSRADIO_RadioAddress = Convert.ToUInt32((Int64)MapData.Rows[0]["Adresse"] - 10000000000);
|
|
// var SENSUSRADIO_PowerLevel = Convert.ToUInt32(MapData.Rows[0]["SENSUSRADIO_PowerLevel"]);
|
|
// var SENSUSRADIO_PowerLevelOption =
|
|
// Convert.ToUInt32(MapData.Rows[0]["SENSUSRADIO_PowerLevelOption"]);
|
|
// var SENSUSRADIO_ImpedanceCodeNew =
|
|
// Convert.ToUInt32(MapData.Rows[0]["SENSUSRADIO_ImpedanceCodeNew"]);
|
|
// var SENSUSRADIO_ImpedanceCodeOption =
|
|
// Convert.ToUInt32(MapData.Rows[0]["SENSUSRADIO_ImpedanceCodeOption"]);
|
|
|
|
|
|
// overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_RadioAddress",
|
|
// SENSUSRADIO_RadioAddress, true, true));
|
|
// overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_PowerLevel", SENSUSRADIO_PowerLevel,
|
|
// true, true));
|
|
// overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_PowerLevelOption",
|
|
// SENSUSRADIO_PowerLevelOption, true, true));
|
|
// overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_ImpedanceCodeNew",
|
|
// SENSUSRADIO_ImpedanceCodeNew, true, true));
|
|
// overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_ImpedanceCodeOption",
|
|
// SENSUSRADIO_ImpedanceCodeOption, true, true));
|
|
|
|
|
|
//}
|
|
|
|
////MapData.Rows[0]["Adresse"]
|
|
|
|
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_SealDisplay",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x01 }).Reverse().ToArray(), true, true));
|
|
|
|
////radio end state!
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_SystemState",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0xFF }).Reverse().ToArray(), true, false));
|
|
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_SystemState",
|
|
// (new Byte[] { 0x00, 0x00, 0x00, 0x02 }).Reverse().ToArray(), true, true));
|
|
|
|
//var sbR = new StringBuilder();
|
|
//if (overAllResult.Any(a => a.Item2 == false))
|
|
//{
|
|
|
|
// foreach (var failedIndex in overAllResult)
|
|
// {
|
|
// if (!failedIndex.Item2)
|
|
// {
|
|
// sbR.AppendLine($"Register={failedIndex.Item1} failed");
|
|
// }
|
|
|
|
// }
|
|
//}
|
|
//else
|
|
//{
|
|
// sbR.AppendLine($"done without errors");
|
|
//}
|
|
|
|
//_currentGenesis.Logout();
|
|
//MessageBox.Show("Result:" + sbR.ToString());
|
|
|
|
//#endregion
|
|
|
|
////radio
|
|
////storeconfig _all
|
|
////log out
|
|
////using (var dataacces = new SqlDataAccess(GlobalConfig.connectionString.Value))
|
|
////{
|
|
|
|
//var resultDic = new Dictionary<string, object>();
|
|
|
|
// resultDic.Add("SENSUSRADIO_RadioAddress", ra);
|
|
|
|
// //10412000966
|
|
|
|
//resultDic.Add("SENSUSRADIO_EncryptionKey", new Byte[] {0x40, 0x28, 0x98, 0xCE, 0x00});
|
|
|
|
//}
|
|
|
|
|
|
////radio
|
|
|
|
// //[Adresse]
|
|
|
|
|
|
|
|
// var listToCheckProgramm = new Dictionary<string, byte[]>();
|
|
|
|
//listToCheckProgramm.Add("", new byte[]{ 0x00, 0x00, 0x00, 0x00});
|
|
|
|
//listToCheckProgramm.Add("", new byte[] { 0x00, 0x00, 0x00, 0x00 });
|
|
|
|
//listToCheckProgramm.Add("", new byte[] { 0x00, 0x00, 0x00, 0x00 });
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
}
|
|
|
|
public Tuple<String, Boolean> _currentGenesis_WriteRegister<T>(String reg, T value, Boolean waitForResult = true,
|
|
Boolean checkRegister = false)
|
|
{
|
|
return new Tuple<String, Boolean>(reg,
|
|
_currentGenesis.WriteRegister(reg, value, waitForResult, checkRegister));
|
|
}
|
|
|
|
private void btnJsonCheck_Click(Object sender, EventArgs e)
|
|
{
|
|
if (_currentGenesis != null)
|
|
{
|
|
var allSucceed = true;
|
|
var List = _currentGenesis.GetRegistersDic().Keys.ToList();
|
|
foreach (var VARIABLE in List)
|
|
{
|
|
|
|
if ((VARIABLE.RegisterDetail.Privilege.Lvl8 == Access.RO
|
|
|| VARIABLE.RegisterDetail.Privilege.Lvl8 == Access.RW)
|
|
)
|
|
{
|
|
var a = _currentGenesis.ReadRegister(VARIABLE.GetIdent());
|
|
//String result = RegisterCheck.CheckRange(VARIABLE, a);
|
|
if (StatusReturn.Failed == RegisterCheck.CheckRange(VARIABLE, a, out var result))
|
|
{
|
|
MessageBox.Show(result);
|
|
allSucceed = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (allSucceed)
|
|
{
|
|
MessageBox.Show(@"Json Check Succeed!");
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show(@"Json Check Failed!");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void btnReadyForTestBench_Click(Object sender, EventArgs e)
|
|
{
|
|
if (_currentGenesis != null)
|
|
{
|
|
|
|
_currentGenesis.ReLogin();
|
|
|
|
//var rees1 = _currentGenesis.ReadRegister("SENSUSRADIO_EncryptionKey",32);
|
|
//var rees2 = _currentGenesis.ReadRegister("SENSUSRADIO_Authentification", 32);
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_EncryptionKey", (new Byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
|
|
//overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_Authentification", (new Byte[] { 0x14, 0x30, 0x68, 0xD0, 0x14, 0x0E, 0x80, 0x40, 0x63, 0x93, 0x73, 0x22 }).Reverse().ToArray(), true, true));
|
|
|
|
_currentGenesis_WriteRegister("GENESISFLOW_LowFlowMaxPeriod", 60 << 16, true, true);
|
|
|
|
|
|
_currentGenesis.ResetAlarm(Alarm.EMPTY_PIPE | Alarm.REBOOT);
|
|
//TODO set display unit
|
|
//TODO calculated overflow volume for display
|
|
_currentGenesis_WriteRegister("GENESISFLOW_SealDisplay",
|
|
(new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true);
|
|
|
|
_currentGenesis.WriteRegister<Byte>(Register.Genesisflow.SampleRate, 10, checkRegister: true);
|
|
_currentGenesis.WriteRegister(Register.Genesisflow.LedMode, 6, checkRegister: true);
|
|
_currentGenesis.WriteRegister("GENESISFLOW_TriggerActive", 1);
|
|
|
|
_currentGenesis_WriteRegister("GENESISFLOW_DisplayPow10",
|
|
(new Byte[] { 0x00, 0x00, 0x00, 0xFA }).Reverse().ToArray(), true, true);
|
|
|
|
|
|
}
|
|
}
|
|
|
|
private void button1_Click_2(Object sender, EventArgs e)
|
|
{
|
|
if (_currentGenesis != null)
|
|
{
|
|
_currentGenesis.ReLogin();
|
|
_currentGenesis_WriteRegister("GENESISFLOW_SealDisplay",
|
|
(new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true);
|
|
|
|
_currentGenesis_WriteRegister("CUSTOMER_Locale",
|
|
(new Byte[] { 0x00, 0x00, 0x00, 0x24 }).Reverse().ToArray(), true, true);
|
|
|
|
|
|
_currentGenesis_WriteRegister("METROLOGYASST_PulseWeight", (new Byte[] { 0x00, 0x00, 0x0E, 0xC9 }).Reverse().ToArray(), true, true);
|
|
_currentGenesis_WriteRegister("METROLOGYASST_FlowPoint", (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true);
|
|
_currentGenesis_WriteRegister("METROLOGYASST_TemperatureUnits", (new Byte[] { 0x00, 0x00, 0x00, 0x01 }).Reverse().ToArray(), true, true);
|
|
_currentGenesis_WriteRegister("METROLOGYASST_FlowUnits", (new Byte[] { 0x00, 0x00, 0x00, 0x06 }).Reverse().ToArray(), true, true);
|
|
_currentGenesis_WriteRegister("GENESISFLOW_DisplayUnits", (new Byte[] { 0x00, 0x00, 0x00, 0x02 }).Reverse().ToArray(), true, true);
|
|
|
|
|
|
_currentGenesis_WriteRegister("GENESISFLOW_SealDisplay",
|
|
(new Byte[] { 0x00, 0x00, 0x00, 0x01 }).Reverse().ToArray(), true, true);
|
|
|
|
|
|
|
|
}
|
|
}
|
|
|
|
private void button2_Click_1(Object sender, EventArgs e)
|
|
{
|
|
_currentGenesis_WriteRegister("GENESISFLOW_SealDisplay",
|
|
(new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true);
|
|
|
|
|
|
_currentGenesis_WriteRegister("CUSTOMER_Locale",
|
|
(new Byte[] { 0x00, 0x00, 0x00, 0xD0 }).Reverse().ToArray(), true, true);
|
|
|
|
_currentGenesis_WriteRegister("METROLOGYASST_PulseWeight", (new Byte[] { 0x00, 0x00, 0x03, 0xE8 }).Reverse().ToArray(), true, true);
|
|
_currentGenesis_WriteRegister("METROLOGYASST_FlowPoint", (new Byte[] { 0x00, 0x00, 0x00, 0x02 }).Reverse().ToArray(), true, true);
|
|
_currentGenesis_WriteRegister("METROLOGYASST_TemperatureUnits", (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true);
|
|
_currentGenesis_WriteRegister("METROLOGYASST_FlowUnits", (new Byte[] { 0x00, 0x00, 0x00, 0x04 }).Reverse().ToArray(), true, true);
|
|
_currentGenesis_WriteRegister("GENESISFLOW_DisplayUnits", (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true);
|
|
|
|
_currentGenesis_WriteRegister("GENESISFLOW_SealDisplay",
|
|
(new Byte[] { 0x00, 0x00, 0x00, 0x01 }).Reverse().ToArray(), true, true);
|
|
}
|
|
|
|
private void registerGridView_CellClick(Object sender, DataGridViewCellEventArgs e)
|
|
{
|
|
if (e.ColumnIndex > 0 && registerGridView.Columns[e.ColumnIndex] is DataGridViewButtonColumn)
|
|
{
|
|
if (_currentGenesis != null && _currentGenesis.IsLoggedOn)
|
|
{
|
|
var regdef = (String)registerGridView.Rows[e.RowIndex].Cells[0].Value;
|
|
var keyvalueRegdef = _currentGenesis.GetRegistersDic().FirstOrDefault(f => f.Key.GetIdent() == regdef);
|
|
if (keyvalueRegdef.Key != null)
|
|
{
|
|
/*var frmDialog = new FrmRegisterHistory(_currentGenesis.PcbId, keyvalueRegdef.Key);
|
|
frmDialog.SetDesktopLocation(Cursor.Position.X, Cursor.Position.Y);
|
|
frmDialog.ShowDialog();*///...MF
|
|
}
|
|
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
private String _preSelectReminder = "None";
|
|
|
|
private void lblState_Click(Object sender, EventArgs e)
|
|
{
|
|
if (_preSelectReminder.Contains("None"))
|
|
{
|
|
_preSelectReminder = "All";
|
|
SelectPreset("All");
|
|
}
|
|
else
|
|
{
|
|
_preSelectReminder = "None";
|
|
SelectPreset("None");
|
|
}
|
|
}
|
|
|
|
private void btnSetDefaultPulse_Click(Object sender, EventArgs e)
|
|
{
|
|
if (_currentGenesis != null)
|
|
{
|
|
_currentGenesis.ReLogin();
|
|
btnSetDefaultPulse.BackColor = Color.Yellow;
|
|
try
|
|
{
|
|
if (_currentGenesis.IsLoggedOn)
|
|
{
|
|
_currentGenesis.WriteRegister("METROLOGYASST_PulseMode", 1);
|
|
|
|
_currentGenesis.WriteRegister("METROLOGYASST_PulseWeight", 32000);
|
|
|
|
_currentGenesis.WriteRegister("METROLOGYASST_PulseLength", 8);
|
|
_currentGenesis.WriteRegister("GENESISFLOW_SampleRate", 2);
|
|
_currentGenesis.WriteRegister("GENESISFLOW_LedMode", 0);
|
|
|
|
_currentGenesis.WriteRegister("GENESISFLOW_TriggerActive", 1);
|
|
|
|
btnSetDefaultPulse.BackColor = Color.Green;
|
|
_currentGenesis.Logout();
|
|
return;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message);
|
|
}
|
|
|
|
_currentGenesis.Logout();
|
|
btnSetDefaultPulse.BackColor = Color.Red;
|
|
}
|
|
}
|
|
|
|
private void btnBatteryIdle_Click(Object sender, EventArgs e)
|
|
{
|
|
if (_currentGenesis != null)
|
|
{
|
|
_currentGenesis.ReLogin();
|
|
btnBatteryIdle.BackColor = Color.Yellow;
|
|
try
|
|
{
|
|
var ts = DateTimeOffset.UtcNow - new DateTimeOffset(2000, 1, 1, 0, 0, 0, new TimeSpan(0));
|
|
if (_currentGenesis.IsLoggedOn)
|
|
{
|
|
_currentGenesis.WriteRegister("GENESISFLOW_SealDisplay", 0);
|
|
_currentGenesis.WriteRegister("POWERMON_WarnFromClamp", (UInt32)473040000);
|
|
_currentGenesis.WriteRegister("SYSTEM_CalendarSeconds", Convert.ToInt32(ts.TotalSeconds));
|
|
var r = _currentGenesis.ReadRegister(Register.Genesisflow.TriggerIdle);
|
|
if (r[1] == 18)
|
|
{
|
|
var newVal = r[0] + 0x01;
|
|
var n = new Byte[] { (Byte)newVal, r[1], 0x00, 0x00 };
|
|
|
|
_currentGenesis.WriteRegister(Register.Genesisflow.TriggerIdle, n);
|
|
}
|
|
else
|
|
{
|
|
_currentGenesis.SetLcdText(false, new Byte[] { 0x12, 0x35 });
|
|
}
|
|
|
|
btnBatteryIdle.BackColor = Color.Green;
|
|
_currentGenesis.Logout();
|
|
return;
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message);
|
|
}
|
|
|
|
btnBatteryIdle.BackColor = Color.Red;
|
|
_currentGenesis.Logout();
|
|
}
|
|
}
|
|
|
|
private void label1_Click(Object sender, EventArgs e)
|
|
{
|
|
|
|
}
|
|
|
|
private void btnStoreAll_Click(Object sender, EventArgs e)
|
|
{
|
|
if (_currentGenesis != null)
|
|
{
|
|
_currentGenesis.ReLogin();
|
|
btnStoreAll.BackColor = Color.Yellow;
|
|
try
|
|
{
|
|
if (_currentGenesis.IsLoggedOn)
|
|
{
|
|
var resultAll = _currentGenesis.StoreAllConfigurations();
|
|
if (resultAll)
|
|
{
|
|
btnStoreAll.BackColor = Color.Green;
|
|
_currentGenesis.Logout();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message);
|
|
}
|
|
|
|
_currentGenesis.Logout();
|
|
btnStoreAll.BackColor = Color.Red;
|
|
}
|
|
}
|
|
|
|
//private void btn0406_Click(object sender, EventArgs e)
|
|
//{
|
|
// if (cbComSlot.SelectedItem != null) // && cbComSlot.SelectedValue is ListBoxItem)
|
|
// {
|
|
// Int32 slotNR = 0;
|
|
// if (!string.IsNullOrEmpty(cbComSlot.SelectedItem.ToString()) &&
|
|
// int.TryParse(cbComSlot.SelectedItem.ToString(), out slotNR))
|
|
// {
|
|
|
|
// btn0406.BackColor = Color.Yellow;
|
|
// try
|
|
// {
|
|
// foreach (var me in _meterBatch.ListOfMeters)
|
|
// {
|
|
// if (me is GenesisMeter)
|
|
// {
|
|
// if (((GenesisMeter)me).IsLoggedOn)
|
|
// {
|
|
// _currentGenesis = ((GenesisMeter)me);
|
|
|
|
|
|
|
|
// _currentGenesis.WriteRegister("CUSTOMER_StoreConfiguration", 1);
|
|
|
|
// var reboot = ByteArrayStyle.ByteStyler.ToString(_currentGenesis.ReadRegister("CUSTOMER_RebootCount"));
|
|
// var PERIODICLOG_ResetCounter = ByteArrayStyle.ByteStyler.ToString(_currentGenesis.ReadRegister("PERIODICLOG_ResetCounter"));
|
|
// var SENSUSRADIO_ResetCounter = ByteArrayStyle.ByteStyler.ToString(_currentGenesis.ReadRegister("SENSUSRADIO_ResetCounter"));
|
|
|
|
// var rebootSeconds = ByteArrayStyle.ByteStyler.ToString(_currentGenesis.ReadRegister("SYSTEM_MonotonicSeconds"));
|
|
// var Storeconfig = ByteArrayStyle.ByteStyler.ToString(_currentGenesis.ReadRegister("CUSTOMER_StoreConfiguration"));
|
|
// _currentGenesis.WriteLog($"#+#+#{_currentGenesis.PcbId};{Storeconfig};{reboot};{rebootSeconds};{cbProd.Checked};{txtTest.Text};{PERIODICLOG_ResetCounter};{SENSUSRADIO_ResetCounter}");
|
|
|
|
// btn0406.BackColor = Color.Green;
|
|
// btn0406.Text = Storeconfig;
|
|
// return;
|
|
// }
|
|
|
|
// }
|
|
// }
|
|
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// btn0406.BackColor = Color.Red;
|
|
// MessageBox.Show(ex.Message);
|
|
// }
|
|
|
|
|
|
// }
|
|
// }
|
|
//}
|
|
|
|
|
|
private void CheckAndDisplayRebootCount()
|
|
{
|
|
if (_currentGenesis != null)
|
|
{
|
|
_currentGenesis.ReLogin();
|
|
timer1.Enabled = false;
|
|
btnRegisterToFile.BackColor = Color.Yellow;
|
|
try
|
|
{
|
|
|
|
if (_currentGenesis.IsLoggedOn)
|
|
{
|
|
var reboot = _currentGenesis.ReadRegister("CUSTOMER_RebootCount");
|
|
_currentGenesis.ReadRegister("POWERMON_BatteryQuantity");
|
|
_currentGenesis.SetLcdText(false, new Byte[] { 0xAC, reboot[0] });
|
|
btnRegisterToFile.BackColor = Color.Green;
|
|
timer1.Enabled = true;
|
|
_currentGenesis.Logout();
|
|
return;
|
|
}
|
|
|
|
}
|
|
catch (Exception)
|
|
{
|
|
timer1.Enabled = true;
|
|
btnRegisterToFile.BackColor = Color.Red;
|
|
return;
|
|
}
|
|
|
|
_currentGenesis.Logout();
|
|
timer1.Enabled = true;
|
|
btnRegisterToFile.BackColor = Color.Gray;
|
|
}
|
|
}
|
|
|
|
private void timer1_Tick(Object sender, EventArgs e)
|
|
{
|
|
CheckAndDisplayRebootCount();
|
|
}
|
|
|
|
|
|
private void btnBatLife_Click(Object sender, EventArgs e)
|
|
{
|
|
if (_currentGenesis != null)
|
|
{
|
|
_currentGenesis.ReLogin();
|
|
try
|
|
{
|
|
if (_currentGenesis.IsLoggedOn)
|
|
{
|
|
var t = new JustageResults
|
|
{
|
|
pcbId = _currentGenesis.PcbId,
|
|
p1Target = 0,
|
|
p1Value = RegisterConverter.ByteArrayToValue<UInt16>(
|
|
_currentGenesis.ReadRegister(Register.Genesisflow.CalFactor1)),
|
|
p2Target = 0,
|
|
p2Value = RegisterConverter.ByteArrayToValue<UInt16>(
|
|
_currentGenesis.ReadRegister(Register.Genesisflow.CalFactor2)),
|
|
p3Target = 0,
|
|
p3Value = RegisterConverter.ByteArrayToValue<UInt16>(
|
|
_currentGenesis.ReadRegister(Register.Genesisflow.CalFactor3)),
|
|
dt = DateTime.UtcNow
|
|
};
|
|
|
|
try
|
|
{
|
|
var tmpUrl = "http://10.49.40.25/MeterProcessState/api/TestBench/SetCalibrationValues";
|
|
//ToDO: Update to service URl
|
|
|
|
t.PostAsJson<JustageResults>(tmpUrl);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//
|
|
}
|
|
|
|
/*...MF var genesisStatus = new GenesisStatus();
|
|
|
|
if (GenesisStatusHandler.BuildLifeTimeInformation(_currentGenesis, genesisStatus, out _))
|
|
{
|
|
var sbMSG = new StringBuilder();
|
|
sbMSG.AppendLine($"Pcb = {_currentGenesis.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}");
|
|
|
|
MessageBox.Show(sbMSG.ToString(), $@"Battery for {_currentGenesis.PcbId} has remaining life " +
|
|
$@"time of {genesisStatus.RemainingLifeTimeYears:F2} years");
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show(@"Failed to get life time information");
|
|
}*/
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.ToString());
|
|
}
|
|
|
|
_currentGenesis.Logout();
|
|
}
|
|
}
|
|
|
|
private void btnRadioPressure_Click(Object sender, EventArgs e)
|
|
{
|
|
if (_currentGenesis != null)
|
|
{
|
|
btnRadioPressure.BackColor = Color.Yellow;
|
|
_currentGenesis.ReLogin();
|
|
try
|
|
{
|
|
var ret = "Failed";
|
|
if (_currentGenesis.IsLoggedOn)
|
|
{
|
|
|
|
//CUSTOMER_AlarmEnableMask - 00-00-80-53
|
|
//CUSTOMER_AlarmBroadcastMask - 00-00-1F-DC
|
|
//CUSTOMER_AlarmVisualMask - 00-00-1F-DC
|
|
//
|
|
|
|
_currentGenesis.WriteRegister("SENSUSRADIO_MainAlarmMask", new Byte[] { 0x00 });
|
|
_currentGenesis.WriteRegister("SENSUSRADIO_ExtendedAlarmMask", new Byte[] { 0x00 });
|
|
|
|
_currentGenesis.WriteRegister("CUSTOMER_AlarmEnableMask", new Byte[] { 0xD3, 0x9F, 0x00, 0x00 });
|
|
_currentGenesis.WriteRegister("CUSTOMER_AlarmBroadcastMask", new Byte[] { 0xDC, 0x1F, 0x00, 0x00 });
|
|
_currentGenesis.WriteRegister("CUSTOMER_AlarmVisualMask", new Byte[] { 0xDC, 0x1F, 0x00, 0x00 });
|
|
|
|
_currentGenesis.WriteRegister("SENSUSRADIO_SystemState", 0xFF);
|
|
_currentGenesis.Logout();
|
|
Thread.Sleep(3000);
|
|
if (!_currentGenesis.ReLogin())
|
|
{
|
|
Thread.Sleep(5000);
|
|
if (!_currentGenesis.ReLogin())
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
/*var SENSUSRADIO_MainAlarmMask = */
|
|
_currentGenesis.ReadRegister("SENSUSRADIO_MainAlarmMask");
|
|
/*var SENSUSRADIO_ExtendedAlarmMask = */
|
|
_currentGenesis.ReadRegister("SENSUSRADIO_ExtendedAlarmMask");
|
|
|
|
//_currentGenesis.WriteRegister("POWERMON_BatteryQuantity", 2, true, true);
|
|
|
|
//var defEncryptionKey = new List<Byte>();
|
|
//defEncryptionKey.AddRange(new Byte[] { 0x0E, 0x9F, 0xAC, 0xC6 }.ToArray());
|
|
//defEncryptionKey.AddRange(new Byte[] { 0xA0, 0xE1, 0xEF, 0x1C }.ToArray());
|
|
//defEncryptionKey.AddRange(new Byte[] { 0x3B, 0x27, 0xA4, 0x9B }.ToArray());
|
|
//defEncryptionKey.AddRange(new Byte[] { 0xAC, 0x21, 0x65, 0x35 }.ToArray());
|
|
//_currentGenesis.WriteRegister("SENSUSRADIO_EncryptionKey", defEncryptionKey.ToArray(), true);
|
|
|
|
|
|
var freq = RegisterConverter.ByteArrayToValue<UInt32>(_currentGenesis.ReadRegister("SENSUSRADIO_FrequencyIndicator"));
|
|
var radioAddress = RegisterConverter.ByteArrayToValue<UInt32>(_currentGenesis.ReadRegister("SENSUSRADIO_RadioAddress"));
|
|
//_currentGenesis.WriteRegister("SENSUSRADIO_SystemState", 0xFF);
|
|
|
|
//_currentGenesis.WriteRegister("SENSUSRADIO_WakeupInterval", 0);
|
|
//_currentGenesis.Logout();
|
|
//File.AppendAllLines("RadioActivation.log", new[] { $"{freq};{_currentGenesis.PcbId};{RadioAdress};{DateTime.Now}" });
|
|
if (0x02 == RegisterConverter.ByteArrayToValue<Byte>(
|
|
_currentGenesis.ReadRegister("SENSUSRADIO_SystemState")))
|
|
{
|
|
btnRadioPressure.BackColor = Color.Green;
|
|
ret = $"{freq};{_currentGenesis.PcbId};{radioAddress};{DateTime.Now}";
|
|
}
|
|
else
|
|
{
|
|
btnRadioPressure.BackColor = Color.Red;
|
|
|
|
}
|
|
}
|
|
|
|
MessageBox.Show(ret);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
btnRadioPressure.BackColor = Color.Red;
|
|
MessageBox.Show(ex.ToString());
|
|
}
|
|
_currentGenesis.Logout();
|
|
}
|
|
}
|
|
|
|
private void btnCalibrationRestore_Click(Object sender, EventArgs e)
|
|
{
|
|
//foreach (var me in _meterBatch.ListOfMeters)
|
|
//{
|
|
// if (me is GenesisMeter Meter)
|
|
// {
|
|
// if (((GenesisMeter)me).IsLoggedOn)
|
|
// {
|
|
// //check if pcb is in file
|
|
// // no
|
|
// //Pcb , cal valus into txt file
|
|
// // cal value + 0,6
|
|
// // store
|
|
// // update Calvalues
|
|
|
|
// //yes
|
|
// //msg
|
|
// }
|
|
// }
|
|
//}
|
|
}
|
|
|
|
public static Boolean GetCalibrationResultsFromDbperRun(String RunId, CalibrationResults calibResults,
|
|
out String errorMsg)
|
|
{
|
|
errorMsg = "";
|
|
if (null == calibResults)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
var url = "http://sla12iis01.emea.sensus.net/MeterProcessState/api/FinalCheck/CalibrationResults/";
|
|
var requestResponse = LocalWebRequest.GetRequest(url, 30000, out var httpStatus);
|
|
if (httpStatus == HttpStatusCode.OK && !string.IsNullOrEmpty(requestResponse))
|
|
{
|
|
var calibRes = JsonConvert.DeserializeObject<CalibrationResults>(requestResponse);
|
|
// ClassAccess.CopyProperties(calibResults, calibRes);
|
|
var type = typeof(CalibrationResults);
|
|
foreach (var prop in type.GetProperties())
|
|
{
|
|
if (prop.CanWrite)
|
|
prop.SetValue(calibResults, prop.GetValue(calibRes, null), null);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
errorMsg = e.Message;
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private void FingerWeg_Clicked(Object sender, EventArgs args)
|
|
{
|
|
if (_currentGenesis != null)
|
|
{
|
|
_currentGenesis.ReLogin();
|
|
try
|
|
{
|
|
if (_currentGenesis.IsLoggedOn)
|
|
{
|
|
|
|
var Meter_calibrationResult = new CalibrationResult();
|
|
Meter_calibrationResult.MeterSize =
|
|
RegisterConverter.ByteArrayToValue<UInt16>(_currentGenesis.ReadRegister(Register.Genesisflow.MeterSize));
|
|
|
|
//readsOk.Add(ReadRegisterRetry(Meter, "CalFactor1", Register.Genesisflow.CalFactor1, out retByte));
|
|
Meter_calibrationResult.CalFactor1 =
|
|
RegisterConverter.ByteArrayToValue<UInt32>(_currentGenesis.ReadRegister(Register.Genesisflow.CalFactor1));
|
|
//readsOk.Add(ReadRegisterRetry(Meter, "CalFactor2", Register.Genesisflow.CalFactor2, out retByte));
|
|
Meter_calibrationResult.CalFactor2 =
|
|
RegisterConverter.ByteArrayToValue<UInt32>(_currentGenesis.ReadRegister(Register.Genesisflow.CalFactor2));
|
|
//readsOk.Add(ReadRegisterRetry(Meter, "CalFactor3", Register.Genesisflow.CalFactor3, out retByte));
|
|
Meter_calibrationResult.CalFactor3 =
|
|
RegisterConverter.ByteArrayToValue<UInt32>(_currentGenesis.ReadRegister(Register.Genesisflow.CalFactor3));
|
|
//readsOk.Add(ReadRegisterRetry(Meter, "ZeroOffset1", Register.Genesisflow.ZeroOffset1, out retByte));
|
|
Meter_calibrationResult.ZeroOffset1 =
|
|
RegisterConverter.ByteArrayToValue<Int32>(_currentGenesis.ReadRegister(Register.Genesisflow.ZeroOffset1));
|
|
//readsOk.Add(ReadRegisterRetry(Meter, "ZeroOffset2", Register.Genesisflow.ZeroOffset2, out retByte));
|
|
Meter_calibrationResult.ZeroOffset2 =
|
|
RegisterConverter.ByteArrayToValue<Int32>(_currentGenesis.ReadRegister(Register.Genesisflow.ZeroOffset2));
|
|
//readsOk.Add(ReadRegisterRetry(Meter, "ZeroOffset3", Register.Genesisflow.ZeroOffset3, out retByte));
|
|
Meter_calibrationResult.ZeroOffset3 =
|
|
RegisterConverter.ByteArrayToValue<Int32>(_currentGenesis.ReadRegister(Register.Genesisflow.ZeroOffset3));
|
|
//readsOk.Add(ReadRegisterRetry(Meter, "FirstHitUpdatePeriod", Register.Genesisflow.FirstHitUpdatePeriod, out retByte));
|
|
Meter_calibrationResult.FirstHitUpdatePeriod =
|
|
RegisterConverter.ByteArrayToValue<UInt16>(
|
|
_currentGenesis.ReadRegister(Register.Genesisflow.FirstHitUpdatePeriod));
|
|
//readsOk.Add(ReadRegisterRetry(Meter, "FirstHitShift", Register.Genesisflow.FirstHitShift, out retByte));
|
|
Meter_calibrationResult.FirstHitShift =
|
|
RegisterConverter.ByteArrayToValue<UInt16>(_currentGenesis.ReadRegister(Register.Genesisflow.FirstHitShift));
|
|
//readsOk.Add(ReadRegisterRetry(Meter, "FirstHitPercent1", Register.Genesisflow.FirstHitPercent1, out retByte));
|
|
Meter_calibrationResult.FirstHitPercent1 =
|
|
RegisterConverter.ByteArrayToValue<UInt16>(_currentGenesis.ReadRegister(Register.Genesisflow.FirstHitPercent1));
|
|
//readsOk.Add(ReadRegisterRetry(Meter, "FirstHitPercent2", Register.Genesisflow.FirstHitPercent2, out retByte));
|
|
Meter_calibrationResult.FirstHitPercent2 =
|
|
RegisterConverter.ByteArrayToValue<UInt16>(_currentGenesis.ReadRegister(Register.Genesisflow.FirstHitPercent2));
|
|
//readsOk.Add(ReadRegisterRetry(Meter, "FirstHitPercent3", Register.Genesisflow.FirstHitPercent3, out retByte));
|
|
Meter_calibrationResult.FirstHitPercent3 =
|
|
RegisterConverter.ByteArrayToValue<UInt16>(_currentGenesis.ReadRegister(Register.Genesisflow.FirstHitPercent3));
|
|
//readsOk.Add(ReadRegisterRetry(Meter, "ToFTempOffset1", Register.Genesisflow.ToFTempOffset1, out retByte));
|
|
Meter_calibrationResult.ToFTempOffset1 =
|
|
RegisterConverter.ByteArrayToValue<Int32>(_currentGenesis.ReadRegister(Register.Genesisflow.ToFTempOffset1));
|
|
//readsOk.Add(ReadRegisterRetry(Meter, "ToFTempOffset2", Register.Genesisflow.ToFTempOffset2, out retByte));
|
|
Meter_calibrationResult.ToFTempOffset2 =
|
|
RegisterConverter.ByteArrayToValue<Int32>(_currentGenesis.ReadRegister(Register.Genesisflow.ToFTempOffset2));
|
|
|
|
Meter_calibrationResult.ToFTempOffset3 =
|
|
RegisterConverter.ByteArrayToValue<Int32>(_currentGenesis.ReadRegister(Register.Genesisflow.ToFTempOffset3));
|
|
Meter_calibrationResult.AdditionalLogInfos.Add("add info", "restore from meter");
|
|
var exPost = new Exception();
|
|
var code = 0;
|
|
LocalWebRequest.PostRequestAsync($"{ServiceUrls.PostGenesisCalibrationResultUrl()}?PcbId={_currentGenesis.PcbId}",
|
|
ref code, ref exPost, 8000, Meter_calibrationResult);
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//
|
|
}
|
|
|
|
//if (this._currentGenesis is null || !this._currentGenesis.IsLoggedOn)
|
|
//{
|
|
// MessageBox.Show("Not connected!");
|
|
|
|
// return;
|
|
//}
|
|
|
|
//this.SetBusy(true, "Recalibration is running");
|
|
|
|
//if (!this.CheckBatteryLifetime())
|
|
//{
|
|
// this.SetBusy(false);
|
|
|
|
// return;
|
|
//}
|
|
|
|
//var p1Cal = default(int);
|
|
//var p2Cal = default(int);
|
|
//var p3Cal = default(int);
|
|
//var logBuilder = new StringBuilder();
|
|
|
|
//try
|
|
//{
|
|
// var caption = string.Empty;
|
|
// var buttons = MessageBoxButtons.YesNo;
|
|
// var icon = MessageBoxIcon.Question;
|
|
|
|
// int ReadRegister(string name)
|
|
// {
|
|
// var value = default(int);
|
|
|
|
// if (!this._currentGenesis.IsLoggedOn)
|
|
// {
|
|
// if (!this._currentGenesis.ReLogin())
|
|
// {
|
|
// var answer = MessageBox.Show("Relogin failed!\n\nWould you try again?", caption, buttons, icon);
|
|
|
|
// if (answer == DialogResult.Yes)
|
|
// {
|
|
// value = ReadRegister(name);
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// value = RegisterConverter.ByteArrayToValue<int>(this._currentGenesis.ReadRegister(name));
|
|
|
|
// if (value == 0)
|
|
// {
|
|
// var answer = MessageBox.Show($"Reading: {name} failed value is - {value}!\n\nWould you try again?", caption, buttons, icon);
|
|
|
|
// if (answer == DialogResult.Yes)
|
|
// {
|
|
// value = ReadRegister(name);
|
|
// }
|
|
// }
|
|
|
|
// return value;
|
|
// }
|
|
|
|
// p1Cal = ReadRegister(Register.Genesisflow.CalFactor1);
|
|
// p2Cal = ReadRegister(Register.Genesisflow.CalFactor2);
|
|
// p3Cal = ReadRegister(Register.Genesisflow.CalFactor3);
|
|
|
|
// if (p1Cal == 0 || p2Cal == 0 || p3Cal == 0)
|
|
// {
|
|
// return;
|
|
// }
|
|
|
|
// logBuilder.AppendLine();
|
|
// logBuilder.AppendLine($"Old values:");
|
|
// logBuilder.AppendLine($" - P1 CalFactor: {p1Cal}");
|
|
// logBuilder.AppendLine($" - P2 CalFactor: {p2Cal}");
|
|
// logBuilder.AppendLine($" - P3 CalFactor: {p3Cal}");
|
|
//}
|
|
//catch (Exception eRead)
|
|
//{
|
|
// MessageBox.Show($"Read exception: {eRead}");
|
|
|
|
// this.SetBusy(false);
|
|
|
|
// return;
|
|
//}
|
|
|
|
//var httpClient = new HttpClient();
|
|
//var values = new List<Q3Calibration>();
|
|
|
|
//try
|
|
//{
|
|
// using (var httpResponse = await httpClient.GetAsync(ServiceUrls.GetQ3CalibrationsURI(this._currentPcbId)))
|
|
// {
|
|
// var content = await httpResponse.Content.ReadAsStringAsync();
|
|
|
|
// if (httpResponse.IsSuccessStatusCode)
|
|
// {
|
|
// try
|
|
// {
|
|
// values = JsonConvert.DeserializeObject<List<Q3Calibration>>(content);
|
|
// }
|
|
// catch (Exception eParse)
|
|
// {
|
|
// MessageBox.Show($"Parse exception: {eParse}");
|
|
|
|
// this.SetBusy(false);
|
|
|
|
// return;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// MessageBox.Show($"Error: {content}");
|
|
|
|
// this.SetBusy(false);
|
|
|
|
// return;
|
|
// }
|
|
// }
|
|
//}
|
|
//catch (Exception eHttp)
|
|
//{
|
|
// MessageBox.Show($"Http exception: {eHttp}");
|
|
|
|
// this.SetBusy(false);
|
|
|
|
// return;
|
|
//}
|
|
|
|
//if (!values.Any(x => x.P1Off == -0.30001))
|
|
//{
|
|
// try
|
|
// {
|
|
// var requestUri = ServiceUrls.Q3CalibrationResultURL;
|
|
// var requestJson = JsonConvert.SerializeObject(new Q3Calibration
|
|
// {
|
|
// PcbId = this._currentPcbId,
|
|
// P1Off = -0.30001,
|
|
// P1Cal = p1Cal,
|
|
// P2Off = -0.30001,
|
|
// P2Cal = p2Cal,
|
|
// P3Off = -0.30001,
|
|
// P3Cal = p3Cal,
|
|
// });
|
|
// var requestContent = new StringContent(requestJson, Encoding.UTF8, "application/json");
|
|
|
|
// using (var httpResponse = await httpClient.PostAsync(requestUri, requestContent))
|
|
// {
|
|
// var content = await httpResponse.Content.ReadAsStringAsync();
|
|
|
|
// if (httpResponse.IsSuccessStatusCode && int.TryParse($"{content}", out var rowsAffected))
|
|
// {
|
|
// logBuilder.AppendLine($"... old values saved!");
|
|
// }
|
|
// else
|
|
// {
|
|
// MessageBox.Show($"HTTP Error: {content}");
|
|
|
|
// this.SetBusy(false);
|
|
|
|
// return;
|
|
// }
|
|
// }
|
|
// }
|
|
// catch (Exception eHttp)
|
|
// {
|
|
// MessageBox.Show($"Http exception: {eHttp}");
|
|
|
|
// this.SetBusy(false);
|
|
|
|
// return;
|
|
// }
|
|
//}
|
|
|
|
//if (!values.Any(x => x.P1Off == 0.30001))
|
|
//{
|
|
// var offset = 0D;
|
|
|
|
// try
|
|
// {
|
|
// offset = values
|
|
// .OrderByDescending(x => x.Date)
|
|
// .FirstOrDefault()
|
|
// ?.P1Off ?? 0;
|
|
|
|
// if (offset > 0.2)
|
|
// {
|
|
// MessageBox.Show($"Recalibration is not required!");
|
|
|
|
// this.SetBusy(false);
|
|
|
|
// return;
|
|
// }
|
|
// }
|
|
// catch (Exception eLinq)
|
|
// {
|
|
// MessageBox.Show($"LINQ exception: {eLinq}");
|
|
// }
|
|
|
|
// try
|
|
// {
|
|
// p1Cal = (int)Math.Round(p1Cal * (1 + 0.6 / 100), 0);
|
|
// p2Cal = (int)Math.Round(p2Cal * (1 + 0.6 / 100), 0);
|
|
// p3Cal = (int)Math.Round(p3Cal * (1 + 0.6 / 100), 0);
|
|
// }
|
|
// catch (Exception eCalc)
|
|
// {
|
|
// MessageBox.Show($"Calculation exception: {eCalc}");
|
|
|
|
// this.SetBusy(false);
|
|
|
|
// return;
|
|
// }
|
|
|
|
// try
|
|
// {
|
|
// var caption = string.Empty;
|
|
// var buttons = MessageBoxButtons.YesNo;
|
|
// var icon = MessageBoxIcon.Question;
|
|
|
|
// void WriteRegister(string name, int value)
|
|
// {
|
|
// if (!this._currentGenesis.IsLoggedOn)
|
|
// {
|
|
// if (!this._currentGenesis.ReLogin())
|
|
// {
|
|
// var answer = MessageBox.Show("Relogin failed!\n\nWould you try again?", caption, buttons, icon);
|
|
|
|
// if (answer == DialogResult.Yes)
|
|
// {
|
|
// WriteRegister(name, value);
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// if (!this._currentGenesis.WriteRegister(name, value))
|
|
// {
|
|
// var answer = MessageBox.Show($"Writing: {name} = {value} failed!\n\nWould you try again?", caption, buttons, icon);
|
|
|
|
// if (answer == DialogResult.Yes)
|
|
// {
|
|
// WriteRegister(name, value);
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// WriteRegister(Register.Genesisflow.SealDisplay, 0);
|
|
// WriteRegister(Register.Genesisflow.TriggerIdle, 0);
|
|
// WriteRegister(Register.Genesisflow.CalFactor1, p1Cal);
|
|
// WriteRegister(Register.Genesisflow.CalFactor2, p2Cal);
|
|
// WriteRegister(Register.Genesisflow.CalFactor3, p3Cal);
|
|
// WriteRegister(Register.Genesisflow.DisplayUnits, 0);
|
|
// WriteRegister(Register.Metrologyasst.FlowUnits, 4);
|
|
// WriteRegister(Register.Genesisflow.DisplayPow10, -6);
|
|
// WriteRegister(Register.Genesisflow.SealDisplay, 1);
|
|
// WriteRegister(Register.Genesisflow.StoreConfiguration, 1);
|
|
|
|
// logBuilder.AppendLine();
|
|
// logBuilder.AppendLine($"New values:");
|
|
// logBuilder.AppendLine($" - P1 CalFactor: {p1Cal}");
|
|
// logBuilder.AppendLine($" - P2 CalFactor: {p2Cal}");
|
|
// logBuilder.AppendLine($" - P3 CalFactor: {p3Cal}");
|
|
// }
|
|
// catch (Exception eWrite)
|
|
// {
|
|
// MessageBox.Show($"Write exception: {eWrite}");
|
|
|
|
// this.SetBusy(false);
|
|
|
|
// return;
|
|
// }
|
|
|
|
// var newValuesWriten = false;
|
|
|
|
// try
|
|
// {
|
|
// //var requestUri = ServiceUrls.Q3CalibrationResultURL;
|
|
// //var requestJson = JsonConvert.SerializeObject(new Q3Calibration
|
|
// //{
|
|
// // PcbId = this._currentPcbId,
|
|
// // P1Off = 0.30001,
|
|
// // P1Cal = p1Cal,
|
|
// // P2Off = 0.30001,
|
|
// // P2Cal = p2Cal,
|
|
// // P3Off = 0.30001,
|
|
// // P3Cal = p3Cal,
|
|
// //});
|
|
// var requestContent = new StringContent(requestJson, Encoding.UTF8, "application/json");
|
|
|
|
// using (var httpResponse = await httpClient.PostAsync(requestUri, requestContent))
|
|
// {
|
|
// var content = await httpResponse.Content.ReadAsStringAsync();
|
|
|
|
// if (httpResponse.IsSuccessStatusCode && int.TryParse($"{content}", out var rowsAffected))
|
|
// {
|
|
// newValuesWriten = rowsAffected > 0;
|
|
// }
|
|
// else
|
|
// {
|
|
// MessageBox.Show($"HTTP Error: {content}");
|
|
|
|
// this.SetBusy(false);
|
|
|
|
// return;
|
|
// }
|
|
// }
|
|
// }
|
|
// catch (Exception eHttp)
|
|
// {
|
|
// MessageBox.Show($"HTTP exception: {eHttp}");
|
|
|
|
// this.SetBusy(false);
|
|
|
|
// return;
|
|
// }
|
|
|
|
// if (newValuesWriten)
|
|
// {
|
|
// logBuilder.AppendLine("... new values saved!");
|
|
|
|
// foreach (var row in this._dataTable.Rows)
|
|
// {
|
|
// if (row is DataRow dataRow && dataRow["Name"] is string registerName)
|
|
// {
|
|
// dataRow["isChecked"] = registerName == Register.Genesisflow.SealDisplay
|
|
// || registerName == Register.Genesisflow.CalFactor1
|
|
// || registerName == Register.Genesisflow.CalFactor2
|
|
// || registerName == Register.Genesisflow.CalFactor3
|
|
// || registerName == Register.Genesisflow.DisplayUnits
|
|
// || registerName == Register.Genesisflow.DisplayPow10
|
|
// || registerName == Register.Genesisflow.StoreConfiguration
|
|
// || registerName == Register.Genesisflow.TriggerIdle
|
|
// || registerName == Register.Metrologyasst.FlowUnits;
|
|
// }
|
|
// }
|
|
|
|
// this.btnRead_Click(sender, args);
|
|
// }
|
|
// else
|
|
// {
|
|
// MessageBox.Show($"Q3Calibration values are not saved!");
|
|
|
|
// this.SetBusy(false);
|
|
|
|
// return;
|
|
// }
|
|
//}
|
|
//else
|
|
//{
|
|
// MessageBox.Show($"Already recalibrated!");
|
|
|
|
// this.SetBusy(false);
|
|
|
|
// return;
|
|
//}
|
|
|
|
//MessageBox.Show(logBuilder.ToString(), $"{this._currentPcbId} - successfully recalibrated", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
_currentGenesis.Logout();
|
|
}
|
|
}
|
|
|
|
private void btnRegisterToFile_Click(Object sender, EventArgs e)
|
|
{
|
|
SelectPreset("All");
|
|
var j = ReadRegisters();
|
|
|
|
var saveFileDialog1 = new SaveFileDialog();
|
|
saveFileDialog1.Filter = @"Register Back Up files (*.rbu)|*.rbu";
|
|
saveFileDialog1.FilterIndex = 1;
|
|
saveFileDialog1.RestoreDirectory = true;
|
|
|
|
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
|
|
{
|
|
File.WriteAllText(saveFileDialog1.FileName, JsonConvert.SerializeObject(j));
|
|
}
|
|
}
|
|
|
|
private void btnFileToRegister_Click(Object sender, EventArgs e)
|
|
{
|
|
if (_currentGenesis != null)
|
|
{
|
|
_currentGenesis.ReLogin();
|
|
|
|
RegisterRestoreData DataShow = null;
|
|
using (var openFileDialog = new OpenFileDialog())
|
|
{
|
|
openFileDialog.Filter = @"Register Back Up files (*.rbu)|*.rbu";
|
|
openFileDialog.FilterIndex = 2;
|
|
openFileDialog.RestoreDirectory = true;
|
|
|
|
if (openFileDialog.ShowDialog() == DialogResult.OK)
|
|
{
|
|
//Get the path of specified file
|
|
var filePath = openFileDialog.FileName;
|
|
|
|
DataShow = JsonConvert.DeserializeObject<RegisterRestoreData>(File.ReadAllText(filePath));
|
|
}
|
|
}
|
|
|
|
var stringBuilder = new StringBuilder();
|
|
var NotStringBuilder = new StringBuilder();
|
|
if (DataShow != null)
|
|
{
|
|
foreach (var RestoreItem in DataShow.RegisterList)
|
|
{
|
|
var meterRegisters = _currentGenesis.GetConfigRegistersDefinitions();
|
|
var regDef = meterRegisters.GetRegisterDefinitionByName(RestoreItem.Key);
|
|
var RegValue = RestoreItem.Value;
|
|
|
|
|
|
/*if (RestoreItem.Value != null
|
|
&& regDef.RegisterDetail != null
|
|
&& regDef.RegisterDetail.Privilege.Lvl8 == Access.RW
|
|
&& regDef.DataType != typeof(RPC))
|
|
{
|
|
_currentGenesis.ReLogin();
|
|
var comp = _currentGenesis.ReadRegister(RestoreItem.Key);
|
|
|
|
if (BitConverter.ToString(RegValue) == BitConverter.ToString(comp))
|
|
{
|
|
NotStringBuilder.AppendLine(
|
|
$"Register not changed ! {RestoreItem.Key} to {BitConverter.ToString(RegValue)}");
|
|
}
|
|
else
|
|
{
|
|
if (regDef.AppName == "CONFIGEXCHANGE" || regDef.AppName == "FLEXNETSERIAL" ||
|
|
regDef.AppName == "FUNCTEST" || regDef.AppName == "NFC" || regDef.AppName == "TESTMANAGER")
|
|
{
|
|
NotStringBuilder.AppendLine(
|
|
$"AppBlocked ! {RestoreItem.Key} to {BitConverter.ToString(RegValue)}");
|
|
}
|
|
else
|
|
{
|
|
stringBuilder.AppendLine(
|
|
$"{RestoreItem.Key} from {BitConverter.ToString(comp)} to {BitConverter.ToString(RegValue)}");
|
|
|
|
if (regDef.DataType != typeof(String))
|
|
RegValue = RegValue.Reverse().ToArray();
|
|
_currentGenesis.WriteRegister(RestoreItem.Key, RegValue, checkRegister: true);
|
|
}
|
|
}
|
|
}*///...MF
|
|
}
|
|
}
|
|
|
|
_currentGenesis.Logout();
|
|
|
|
//...MF MessageBox.Show(stringBuilder.ToString());
|
|
//...MF MessageBox.Show(NotStringBuilder.ToString());
|
|
}
|
|
}
|
|
|
|
private void cbxUseOfflinePwds_CheckedChanged(Object sender, EventArgs e)
|
|
{
|
|
cbxUseOfflinePwds.ForeColor = cbxUseOfflinePwds.Checked ? Color.Red : Color.Black;
|
|
}
|
|
}
|
|
} |