From f2da177517728a512b9ca731eb8dce918720bc3c Mon Sep 17 00:00:00 2001 From: Milan Hanajik Date: Fri, 31 Jul 2015 10:45:50 +0200 Subject: [PATCH] Modbus and QuidoRS components added WaterMeters folder created, WaterMeter component relocated within the project, iPerl component added WaterMeters.iPerl implements IRegisterReader interface, TODO: Implement WaterMeter.ReadPulses( ) function iPerlAdjustment test method added --- TestBenchFramework/BenchControl/Events.cs | 1 + .../BenchControl/GenericDevices/IModbus.cs | 12 + .../BenchControl/Modbus/Common/Factory.cs | 23 + .../BenchControl/Modbus/Common/Modbus.cs | 124 ++ .../BenchControl/Modbus/Common/ModbusCfg.cs | 52 + .../Modbus/Common/ModbusCfgCtrl.cs | 173 +++ .../Modbus/Common/ModbusCfgCtrl.designer.cs | 229 +++ .../Common/ModbusCfgCtrl.resx} | 0 .../BenchControl/Modbus/Enums.cs | 20 + .../BenchControl/Modbus/QuidoRS/Factory.cs | 23 + .../BenchControl/Modbus/QuidoRS/QuidoRS.cs | 83 + .../BenchControl/Modbus/QuidoRS/QuidoRSCfg.cs | 44 + .../Modbus/QuidoRS/QuidoRSCfgCtrl.cs | 106 ++ .../Modbus/QuidoRS/QuidoRSCfgCtrl.designer.cs | 133 ++ .../Modbus/QuidoRS/QuidoRSCfgCtrl.resx | 120 ++ .../Modbus/QuidoRS/SetOutputsOp.cs | 57 + .../BenchControl/TbfComponents.cs | 14 +- .../TestMethods/iPerlAdjustment/TestMethod.cs | 35 + .../iPerlAdjustment/TestMethodCfg.cs | 35 + .../iPerlAdjustment/TestMethodCfgCtrl.cs | 71 + .../TestMethodCfgCtrl.designer.cs | 86 ++ .../iPerlAdjustment/TestMethodCfgCtrl.resx | 120 ++ .../iPerlAdjustment/TestMethodFactory.cs | 23 + .../iPerlAdjustment/iPerlAdjustmentSeq.cs | 127 ++ .../iPerlAdjustment/iPerlCommunicationForm.cs | 266 ++++ .../iPerlCommunicationForm.designer.cs | 1366 +++++++++++++++++ .../iPerlCommunicationForm.resx | 120 ++ .../WaterMeter/ProcParams.cs | 2 +- .../WaterMeter/WaterMeter.cs | 2 +- .../WaterMeter/WaterMeterCfg.cs | 2 +- .../WaterMeter/WaterMeterCfgCtrl.cs | 4 +- .../WaterMeter/WaterMeterCfgCtrl.designer.cs | 4 +- .../WaterMeter/WaterMeterCfgCtrl.resx | 120 ++ .../WaterMeter/WaterMeterFactory.cs | 2 +- .../WaterMeters/iPerl/CalibrationStruct.cs | 143 ++ .../WaterMeters/iPerl/ConfigStruct.cs | 123 ++ .../WaterMeters/iPerl/ProcParams.cs | 128 ++ .../WaterMeters/iPerl/StatusStruct.cs | 160 ++ .../WaterMeters/iPerl/WaterMeter.cs | 145 ++ .../WaterMeters/iPerl/WaterMeterCfg.cs | 60 + .../WaterMeters/iPerl/WaterMeterCfgCtrl.cs | 100 ++ .../iPerl/WaterMeterCfgCtrl.designer.cs | 155 ++ .../WaterMeters/iPerl/WaterMeterCfgCtrl.resx | 120 ++ .../WaterMeters/iPerl/WaterMeterFactory.cs | 23 + TestBenchFramework/Properties/AssemblyInfo.cs | 4 +- TestBenchFramework/TBF.csproj | 86 +- .../Fuzhou150/ControlComponent3U.dll | Bin 342016 -> 397824 bytes 47 files changed, 4819 insertions(+), 27 deletions(-) create mode 100644 TestBenchFramework/BenchControl/GenericDevices/IModbus.cs create mode 100644 TestBenchFramework/BenchControl/Modbus/Common/Factory.cs create mode 100644 TestBenchFramework/BenchControl/Modbus/Common/Modbus.cs create mode 100644 TestBenchFramework/BenchControl/Modbus/Common/ModbusCfg.cs create mode 100644 TestBenchFramework/BenchControl/Modbus/Common/ModbusCfgCtrl.cs create mode 100644 TestBenchFramework/BenchControl/Modbus/Common/ModbusCfgCtrl.designer.cs rename TestBenchFramework/BenchControl/{WaterMeter/WaterMeterCfgCtrl.resx => Modbus/Common/ModbusCfgCtrl.resx} (100%) create mode 100644 TestBenchFramework/BenchControl/Modbus/Enums.cs create mode 100644 TestBenchFramework/BenchControl/Modbus/QuidoRS/Factory.cs create mode 100644 TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRS.cs create mode 100644 TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRSCfg.cs create mode 100644 TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRSCfgCtrl.cs create mode 100644 TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRSCfgCtrl.designer.cs create mode 100644 TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRSCfgCtrl.resx create mode 100644 TestBenchFramework/BenchControl/Modbus/QuidoRS/SetOutputsOp.cs create mode 100644 TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethod.cs create mode 100644 TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodCfg.cs create mode 100644 TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodCfgCtrl.cs create mode 100644 TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodCfgCtrl.designer.cs create mode 100644 TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodCfgCtrl.resx create mode 100644 TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodFactory.cs create mode 100644 TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/iPerlAdjustmentSeq.cs create mode 100644 TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/iPerlCommunicationForm.cs create mode 100644 TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/iPerlCommunicationForm.designer.cs create mode 100644 TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/iPerlCommunicationForm.resx rename TestBenchFramework/BenchControl/{ => WaterMeters}/WaterMeter/ProcParams.cs (98%) rename TestBenchFramework/BenchControl/{ => WaterMeters}/WaterMeter/WaterMeter.cs (97%) rename TestBenchFramework/BenchControl/{ => WaterMeters}/WaterMeter/WaterMeterCfg.cs (96%) rename TestBenchFramework/BenchControl/{ => WaterMeters}/WaterMeter/WaterMeterCfgCtrl.cs (92%) rename TestBenchFramework/BenchControl/{ => WaterMeters}/WaterMeter/WaterMeterCfgCtrl.designer.cs (95%) create mode 100644 TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeterCfgCtrl.resx rename TestBenchFramework/BenchControl/{ => WaterMeters}/WaterMeter/WaterMeterFactory.cs (92%) create mode 100644 TestBenchFramework/BenchControl/WaterMeters/iPerl/CalibrationStruct.cs create mode 100644 TestBenchFramework/BenchControl/WaterMeters/iPerl/ConfigStruct.cs create mode 100644 TestBenchFramework/BenchControl/WaterMeters/iPerl/ProcParams.cs create mode 100644 TestBenchFramework/BenchControl/WaterMeters/iPerl/StatusStruct.cs create mode 100644 TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeter.cs create mode 100644 TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterCfg.cs create mode 100644 TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterCfgCtrl.cs create mode 100644 TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterCfgCtrl.designer.cs create mode 100644 TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterCfgCtrl.resx create mode 100644 TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterFactory.cs diff --git a/TestBenchFramework/BenchControl/Events.cs b/TestBenchFramework/BenchControl/Events.cs index 975c1e435..0175bb61c 100644 --- a/TestBenchFramework/BenchControl/Events.cs +++ b/TestBenchFramework/BenchControl/Events.cs @@ -153,5 +153,6 @@ namespace TBF.BenchControl Next, /// To move to the next state when debugging OK, TimerBusy, + SetOutputsDone, } } diff --git a/TestBenchFramework/BenchControl/GenericDevices/IModbus.cs b/TestBenchFramework/BenchControl/GenericDevices/IModbus.cs new file mode 100644 index 000000000..8ad433d02 --- /dev/null +++ b/TestBenchFramework/BenchControl/GenericDevices/IModbus.cs @@ -0,0 +1,12 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using TBF.BenchControl.Generic; + +namespace TBF.BenchControl.GenericDevices +{ + public interface IModbus : IComponent + { + void SendMessage(byte[] message); + } +} diff --git a/TestBenchFramework/BenchControl/Modbus/Common/Factory.cs b/TestBenchFramework/BenchControl/Modbus/Common/Factory.cs new file mode 100644 index 000000000..729e60c1e --- /dev/null +++ b/TestBenchFramework/BenchControl/Modbus/Common/Factory.cs @@ -0,0 +1,23 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using TBF.BenchControl.Generic; + +namespace TBF.BenchControl.Modbus.Common +{ + public class Factory : IComponentFactory + { + public string ClassName { get { return "Modbus"; } } + + public void ResetStaticProperties() { Modbus.ResetStaticProperties(); } + + public IComponent DummyComponent() { return new Modbus(); } + + public IComponentCfg DefaultConfig() { return new ModbusCfg(this); } + + public IComponentCfg CmpntCfgFromCmpntEntity(Entities.Component component) + { + return ComponentCfgBase.CreateFromDbEntity(typeof(ModbusCfg), component, this); + } + } +} diff --git a/TestBenchFramework/BenchControl/Modbus/Common/Modbus.cs b/TestBenchFramework/BenchControl/Modbus/Common/Modbus.cs new file mode 100644 index 000000000..175c08969 --- /dev/null +++ b/TestBenchFramework/BenchControl/Modbus/Common/Modbus.cs @@ -0,0 +1,124 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO.Ports; +using System.Text; +using System.Threading; +using log4net; +using TBF.BenchControl.Generic; +using TBF.Boxes; + +namespace TBF.BenchControl.Modbus.Common +{ + /// + /// Root component for Modbus communication via serial port (RS485) + /// + public class Modbus : ComponentBase, IDevice, GenericDevices.IModbus + { + private static readonly ILog log = LogManager.GetLogger(typeof(Modbus)); + public override string ToString() { return string.Format("Modbus({0})", Cfg.ToString(1)); } + + private readonly ModbusCfg modbusCommonCfg; + + /// Private fields + SerialPort serialPort; + Thread workerThread; + bool stopWorkerThread; + + public Modbus() + { + } + + /// + /// Ambient temperature / humidity / pressure meter 'Greco' connected via serial interface (RS232) + /// Connection settings: 19200 Bd 8-bits No-parity 1-stop-bit Flow control: none or hardware. + /// + public Modbus(ModbusCfg cfg, IList components) + : base(cfg) + { + serialPort = null; + modbusCommonCfg = cfg; + log.Debug(this.ToString()); + } + + ~Modbus() + { + } + + public void Initialize() + { + if (modbusCommonCfg.DebugLevel == Entities.DebugMode.Simulate) + { + return; + } + + string comPortName = "COM" + modbusCommonCfg.ComPortNr.ToString(); + serialPort = new SerialPort(comPortName, modbusCommonCfg.BaudRate, modbusCommonCfg.Parity, modbusCommonCfg.DataBits, modbusCommonCfg.StopBits); + serialPort.Handshake = modbusCommonCfg.Handshake; + serialPort.Open(); + + stopWorkerThread = false; + workerThread = new Thread(Worker); + workerThread.Start(); + + log.FatalFormat("Successfully initialized device {0}", ToString()); + } + + + /// + /// Send a modbus message. + /// This function calculates and overwrites the last 2 bytes + /// of the message - CRC as specified in Modbus specification. + /// + /// Message incl CRC, CRC bytes dont have to be set + public void SendMessage(byte[] message) + { + Telegram.UpdateTelegramCRC(message); + log.Debug(Telegram.LogTelegram("Sending message ", message)); + serialPort.Write(message, 0, message.Length); + } + + void Worker() + { + while (!stopWorkerThread) + { + Thread.Sleep(250); + if (stopWorkerThread) break; + int nrBytes = serialPort.BytesToRead; + if (nrBytes > 0) + { + char[] buffer = new char[nrBytes]; + serialPort.Read(buffer, 0, nrBytes); + string s = Telegram.LogTelegram("Received: ", new string(buffer)); + /// ODO: Add handler + //OnQuidoReceived(this, new QuidoReceivedEventArgs(s)); + } + } + } + + + /// Run this device + public void RunDeviceBefore() + { + } + + /// Run this device + public void RunDeviceAfter() + { + } + + /// Stop this device + public void StopDevice() + { + if (serialPort != null) + { + stopWorkerThread = true; + workerThread.Join(2000); + serialPort.Close(); + } + } + } +} diff --git a/TestBenchFramework/BenchControl/Modbus/Common/ModbusCfg.cs b/TestBenchFramework/BenchControl/Modbus/Common/ModbusCfg.cs new file mode 100644 index 000000000..1ccbed151 --- /dev/null +++ b/TestBenchFramework/BenchControl/Modbus/Common/ModbusCfg.cs @@ -0,0 +1,52 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using System.IO; +using System.Collections.Generic; +using System.IO.Ports; +using System.Xml.Serialization; +using TBF.BenchControl.Generic; + +namespace TBF.BenchControl.Modbus.Common +{ + public class ModbusCfg : ComponentCfgBase, Generic.IComponentCfg + { + public IComponent GetComponent(IList components) { return new Modbus(this, components); } + public IComponentCfgCtrl GetControl() { return new ModbusCfgCtrl(); } + + /// + /// Serialized parameters + /// + public int ComPortNr; + public int BaudRate; + public Parity Parity; + public int DataBits; + public StopBits StopBits; + public Handshake Handshake; + + /// Private parameterless constructor invoked by all other (public) constructors + ModbusCfg() + { + Name = "Modbus"; + ParentName = string.Empty; + ComPortNr = 3; + BaudRate = 9600; + Parity = System.IO.Ports.Parity.None; + DataBits = 8; + StopBits = System.IO.Ports.StopBits.One; + Handshake = System.IO.Ports.Handshake.None; + } + + public ModbusCfg(IComponentFactory factory) + : this() + { + this.Factory = factory; + } + + public string ToString(int i) + { + return string.Format("Name={0}, Com{1}, {2}Bd, {3}-bits, parity={4}, stopBits={5}, {6}", + Name, ComPortNr, BaudRate, DataBits, Parity, StopBits, Handshake); + } + } +} diff --git a/TestBenchFramework/BenchControl/Modbus/Common/ModbusCfgCtrl.cs b/TestBenchFramework/BenchControl/Modbus/Common/ModbusCfgCtrl.cs new file mode 100644 index 000000000..248cedff6 --- /dev/null +++ b/TestBenchFramework/BenchControl/Modbus/Common/ModbusCfgCtrl.cs @@ -0,0 +1,173 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using System; +using System.Windows.Forms; +using System.IO.Ports; +using log4net; +using TBF.BenchControl.Generic; +using TBF.Resources; + +namespace TBF.BenchControl.Modbus.Common +{ + public partial class ModbusCfgCtrl : UserControl, IComponentCfgCtrl + { + static readonly ILog log = LogManager.GetLogger(typeof(ModbusCfgCtrl)); + + public bool ShowMore { get { return false; } } + + ModbusCfg config; + public IComponentCfg Config + { + get { return config as IComponentCfg; } + set + { + config = value as ModbusCfg; + Redraw(); + } + } + + public ModbusCfgCtrl() + { + InitializeComponent(); + + parityComboBox.Items.Add(Parity.None.ToString()); + parityComboBox.Items.Add(Parity.Even.ToString()); + parityComboBox.Items.Add(Parity.Odd.ToString()); + + stopBitsComboBox.Items.Add(StopBits.None.ToString()); + stopBitsComboBox.Items.Add(StopBits.One.ToString()); + stopBitsComboBox.Items.Add(StopBits.OnePointFive.ToString()); + stopBitsComboBox.Items.Add(StopBits.Two.ToString()); + + handshakeComboBox.Items.Add(Handshake.None.ToString()); + handshakeComboBox.Items.Add(Handshake.RequestToSend.ToString()); + handshakeComboBox.Items.Add(Handshake.XOnXOff.ToString()); + } + + int GetParityIx(Parity par) + { + if (par == Parity.None) return 0; + if (par == Parity.Even) return 0; + if (par == Parity.Odd) return 0; + return -1; + } + Parity GetParity(string str) + { + if (str.Equals(Parity.None.ToString())) return Parity.None; + if (str.Equals(Parity.Even.ToString())) return Parity.Even; + if (str.Equals(Parity.Odd.ToString())) return Parity.Odd; + return (Parity)(-1); + } + + int GetStopBitsIx(StopBits sb) + { + if (sb == StopBits.None) return 0; + if (sb == StopBits.One) return 1; + if (sb == StopBits.OnePointFive) return 2; + if (sb == StopBits.Two) return 3; + return -1; + } + StopBits GetStopBits(string str) + { + if (str.Equals(StopBits.None.ToString())) return StopBits.None; + if (str.Equals(StopBits.One.ToString())) return StopBits.One; + if (str.Equals(StopBits.OnePointFive.ToString())) return StopBits.OnePointFive; + if (str.Equals(StopBits.Two.ToString())) return StopBits.Two; + return (StopBits)(-1); + } + + int GetHandshakeIx(Handshake par) + { + if (par == Handshake.None) return 0; + if (par == Handshake.RequestToSend) return 0; + if (par == Handshake.XOnXOff) return 0; + return -1; + } + Handshake GetHandshake(string str) + { + if (str.Equals(Handshake.None.ToString())) return Handshake.None; + if (str.Equals(Handshake.RequestToSend.ToString())) return Handshake.RequestToSend; + if (str.Equals(Handshake.XOnXOff.ToString())) return Handshake.XOnXOff; + return (Handshake)(-1); + } + + private void ModbusCfgCtrl_Load(object sender, EventArgs e) + { + nameLabel.Text = Strings.Name; + Redraw(); + } + + public void Closing() + { + } + + void Redraw() + { + if (config == null) return; /// Control was not loaded, settings were not changed + + classNameLabel.Text = config.Factory.ClassName; + nameTextBox.Text = config.Name; + comPortNrTextBox.Text = config.ComPortNr.ToString(); + baudRateTextBox.Text = config.BaudRate.ToString(); + parityComboBox.Text = config.Parity.ToString(); + dataBitsTextBox.Text = config.DataBits.ToString(); + stopBitsComboBox.Text = config.StopBits.ToString(); + handshakeComboBox.Text = config.Handshake.ToString(); + } + + public void Unlock() + { + nameTextBox.Enabled = true; + comPortNrTextBox.Enabled = true; + baudRateTextBox.Enabled = true; + parityComboBox.Enabled = true; + dataBitsTextBox.Enabled = true; + stopBitsComboBox.Enabled = true; + handshakeComboBox.Enabled = true; + } + + public CfgUpdateFlags UpdateCfg() + { + CfgUpdateFlags flags = CfgUpdateFlags.RestartRqrd; + + if (config == null) return CfgUpdateFlags.Error; /// Control was not loaded, settings were not changed + + config.Name = nameTextBox.Text; + config.ComPortNr = int.Parse(comPortNrTextBox.Text); + config.BaudRate = int.Parse(baudRateTextBox.Text); + config.Parity = GetParity(parityComboBox.SelectedItem.ToString()); + config.DataBits = int.Parse(dataBitsTextBox.Text); + config.StopBits = GetStopBits(stopBitsComboBox.SelectedItem.ToString()); + config.Handshake = GetHandshake(handshakeComboBox.SelectedItem.ToString()); + + return flags; + } + + public CfgUpdateFlags VerifyCfg(ref string message) + { + CfgUpdateFlags flags = CfgUpdateFlags.None; + + int dummy; + if (!int.TryParse(comPortNrTextBox.Text, out dummy) || dummy < 1 || dummy > 999) + { + flags |= CfgUpdateFlags.Error; + message += Environment.NewLine + "'Serial Port Number' is not valid"; + } + + if (!int.TryParse(baudRateTextBox.Text, out dummy) || dummy < 150 || dummy > 115200) + { + flags |= CfgUpdateFlags.Error; + message += Environment.NewLine + "'Baud Rate' is not valid"; + } + + if (!int.TryParse(dataBitsTextBox.Text, out dummy) || dummy < 7 || dummy > 8) + { + flags |= CfgUpdateFlags.Error; + message += Environment.NewLine + "'Data Bits' is not valid"; + } + + return flags; + } + } +} diff --git a/TestBenchFramework/BenchControl/Modbus/Common/ModbusCfgCtrl.designer.cs b/TestBenchFramework/BenchControl/Modbus/Common/ModbusCfgCtrl.designer.cs new file mode 100644 index 000000000..bc07917f0 --- /dev/null +++ b/TestBenchFramework/BenchControl/Modbus/Common/ModbusCfgCtrl.designer.cs @@ -0,0 +1,229 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +namespace TBF.BenchControl.Modbus.Common +{ + partial class ModbusCfgCtrl + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Component Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.comPortNrTextBox = new System.Windows.Forms.TextBox(); + this.label1 = new System.Windows.Forms.Label(); + this.baudRateLabel = new System.Windows.Forms.Label(); + this.baudRateTextBox = new System.Windows.Forms.TextBox(); + this.partityLabel = new System.Windows.Forms.Label(); + this.dataBitsLabel = new System.Windows.Forms.Label(); + this.dataBitsTextBox = new System.Windows.Forms.TextBox(); + this.stopBitsLabel = new System.Windows.Forms.Label(); + this.handshakeLabel = new System.Windows.Forms.Label(); + this.nameTextBox = new System.Windows.Forms.TextBox(); + this.nameLabel = new System.Windows.Forms.Label(); + this.classNameLabel = new System.Windows.Forms.Label(); + this.parityComboBox = new System.Windows.Forms.ComboBox(); + this.stopBitsComboBox = new System.Windows.Forms.ComboBox(); + this.handshakeComboBox = new System.Windows.Forms.ComboBox(); + this.SuspendLayout(); + // + // comPortNrTextBox + // + this.comPortNrTextBox.Enabled = false; + this.comPortNrTextBox.Location = new System.Drawing.Point(140, 52); + this.comPortNrTextBox.Name = "comPortNrTextBox"; + this.comPortNrTextBox.Size = new System.Drawing.Size(34, 20); + this.comPortNrTextBox.TabIndex = 4; + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(29, 55); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(98, 13); + this.label1.TabIndex = 3; + this.label1.Text = "Serial Port Number:"; + // + // baudRateLabel + // + this.baudRateLabel.AutoSize = true; + this.baudRateLabel.Location = new System.Drawing.Point(29, 79); + this.baudRateLabel.Name = "baudRateLabel"; + this.baudRateLabel.Size = new System.Drawing.Size(58, 13); + this.baudRateLabel.TabIndex = 5; + this.baudRateLabel.Text = "Baud Rate"; + // + // baudRateTextBox + // + this.baudRateTextBox.Enabled = false; + this.baudRateTextBox.Location = new System.Drawing.Point(140, 76); + this.baudRateTextBox.Name = "baudRateTextBox"; + this.baudRateTextBox.Size = new System.Drawing.Size(130, 20); + this.baudRateTextBox.TabIndex = 6; + // + // partityLabel + // + this.partityLabel.AutoSize = true; + this.partityLabel.Location = new System.Drawing.Point(29, 103); + this.partityLabel.Name = "partityLabel"; + this.partityLabel.Size = new System.Drawing.Size(33, 13); + this.partityLabel.TabIndex = 7; + this.partityLabel.Text = "Parity"; + // + // dataBitsLabel + // + this.dataBitsLabel.AutoSize = true; + this.dataBitsLabel.Location = new System.Drawing.Point(29, 127); + this.dataBitsLabel.Name = "dataBitsLabel"; + this.dataBitsLabel.Size = new System.Drawing.Size(50, 13); + this.dataBitsLabel.TabIndex = 9; + this.dataBitsLabel.Text = "Data Bits"; + // + // dataBitsTextBox + // + this.dataBitsTextBox.Enabled = false; + this.dataBitsTextBox.Location = new System.Drawing.Point(140, 124); + this.dataBitsTextBox.Name = "dataBitsTextBox"; + this.dataBitsTextBox.Size = new System.Drawing.Size(34, 20); + this.dataBitsTextBox.TabIndex = 10; + // + // stopBitsLabel + // + this.stopBitsLabel.AutoSize = true; + this.stopBitsLabel.Location = new System.Drawing.Point(29, 151); + this.stopBitsLabel.Name = "stopBitsLabel"; + this.stopBitsLabel.Size = new System.Drawing.Size(49, 13); + this.stopBitsLabel.TabIndex = 11; + this.stopBitsLabel.Text = "Stop Bits"; + // + // handshakeLabel + // + this.handshakeLabel.AutoSize = true; + this.handshakeLabel.Location = new System.Drawing.Point(29, 175); + this.handshakeLabel.Name = "handshakeLabel"; + this.handshakeLabel.Size = new System.Drawing.Size(62, 13); + this.handshakeLabel.TabIndex = 13; + this.handshakeLabel.Text = "Handshake"; + // + // nameTextBox + // + this.nameTextBox.Enabled = false; + this.nameTextBox.Location = new System.Drawing.Point(140, 28); + this.nameTextBox.Name = "nameTextBox"; + this.nameTextBox.Size = new System.Drawing.Size(130, 20); + this.nameTextBox.TabIndex = 2; + // + // nameLabel + // + this.nameLabel.AutoSize = true; + this.nameLabel.Location = new System.Drawing.Point(30, 31); + this.nameLabel.Name = "nameLabel"; + this.nameLabel.Size = new System.Drawing.Size(35, 13); + this.nameLabel.TabIndex = 1; + this.nameLabel.Text = "Name"; + // + // classNameLabel + // + this.classNameLabel.AutoSize = true; + this.classNameLabel.Location = new System.Drawing.Point(137, 7); + this.classNameLabel.Name = "classNameLabel"; + this.classNameLabel.Size = new System.Drawing.Size(83, 13); + this.classNameLabel.TabIndex = 0; + this.classNameLabel.Text = "ComonentName"; + // + // parityComboBox + // + this.parityComboBox.Enabled = false; + this.parityComboBox.FormattingEnabled = true; + this.parityComboBox.Location = new System.Drawing.Point(140, 100); + this.parityComboBox.Name = "parityComboBox"; + this.parityComboBox.Size = new System.Drawing.Size(130, 21); + this.parityComboBox.TabIndex = 8; + // + // stopBitsComboBox + // + this.stopBitsComboBox.Enabled = false; + this.stopBitsComboBox.FormattingEnabled = true; + this.stopBitsComboBox.Location = new System.Drawing.Point(140, 148); + this.stopBitsComboBox.Name = "stopBitsComboBox"; + this.stopBitsComboBox.Size = new System.Drawing.Size(130, 21); + this.stopBitsComboBox.TabIndex = 12; + // + // handshakeComboBox + // + this.handshakeComboBox.Enabled = false; + this.handshakeComboBox.FormattingEnabled = true; + this.handshakeComboBox.Location = new System.Drawing.Point(140, 172); + this.handshakeComboBox.Name = "handshakeComboBox"; + this.handshakeComboBox.Size = new System.Drawing.Size(130, 21); + this.handshakeComboBox.TabIndex = 14; + // + // AmbientCfgCtrl + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.SystemColors.Control; + this.Controls.Add(this.handshakeComboBox); + this.Controls.Add(this.stopBitsComboBox); + this.Controls.Add(this.parityComboBox); + this.Controls.Add(this.nameTextBox); + this.Controls.Add(this.nameLabel); + this.Controls.Add(this.classNameLabel); + this.Controls.Add(this.handshakeLabel); + this.Controls.Add(this.stopBitsLabel); + this.Controls.Add(this.dataBitsTextBox); + this.Controls.Add(this.dataBitsLabel); + this.Controls.Add(this.partityLabel); + this.Controls.Add(this.baudRateTextBox); + this.Controls.Add(this.baudRateLabel); + this.Controls.Add(this.comPortNrTextBox); + this.Controls.Add(this.label1); + this.Name = "AmbientCfgCtrl"; + this.Size = new System.Drawing.Size(300, 240); + this.Load += new System.EventHandler(this.ModbusCfgCtrl_Load); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.TextBox comPortNrTextBox; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Label baudRateLabel; + private System.Windows.Forms.TextBox baudRateTextBox; + private System.Windows.Forms.Label partityLabel; + private System.Windows.Forms.Label dataBitsLabel; + private System.Windows.Forms.TextBox dataBitsTextBox; + private System.Windows.Forms.Label stopBitsLabel; + private System.Windows.Forms.Label handshakeLabel; + private System.Windows.Forms.TextBox nameTextBox; + private System.Windows.Forms.Label nameLabel; + private System.Windows.Forms.Label classNameLabel; + private System.Windows.Forms.ComboBox parityComboBox; + private System.Windows.Forms.ComboBox stopBitsComboBox; + private System.Windows.Forms.ComboBox handshakeComboBox; + + } +} diff --git a/TestBenchFramework/BenchControl/WaterMeter/WaterMeterCfgCtrl.resx b/TestBenchFramework/BenchControl/Modbus/Common/ModbusCfgCtrl.resx similarity index 100% rename from TestBenchFramework/BenchControl/WaterMeter/WaterMeterCfgCtrl.resx rename to TestBenchFramework/BenchControl/Modbus/Common/ModbusCfgCtrl.resx diff --git a/TestBenchFramework/BenchControl/Modbus/Enums.cs b/TestBenchFramework/BenchControl/Modbus/Enums.cs new file mode 100644 index 000000000..f4dc749f4 --- /dev/null +++ b/TestBenchFramework/BenchControl/Modbus/Enums.cs @@ -0,0 +1,20 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using System; + +namespace TBF.BenchControl.Modbus +{ + public enum Function : byte + { + ReadCoilStatus = 0x01, + ReadSingleInput = 0x02, + ReadHoldingRegisters = 0x03, + ReadInputRegister = 0x04, + ForceSingleCoil = 0x05, + PresetSingleRegister = 0x06, + ForceMultipleCoils = 0x0F, + PresetMultipleRegisters = 0x10, + Identification = 0x11, + } +} diff --git a/TestBenchFramework/BenchControl/Modbus/QuidoRS/Factory.cs b/TestBenchFramework/BenchControl/Modbus/QuidoRS/Factory.cs new file mode 100644 index 000000000..99276ccbb --- /dev/null +++ b/TestBenchFramework/BenchControl/Modbus/QuidoRS/Factory.cs @@ -0,0 +1,23 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using TBF.BenchControl.Generic; + +namespace TBF.BenchControl.Modbus.QuidoRS +{ + public class Factory : IComponentFactory + { + public string ClassName { get { return "QuidoRS"; } } + + public void ResetStaticProperties() { QuidoRS.ResetStaticProperties(); } + + public IComponent DummyComponent() { return new QuidoRS(); } + + public IComponentCfg DefaultConfig() { return new QuidoRSCfg(this); } + + public IComponentCfg CmpntCfgFromCmpntEntity(Entities.Component component) + { + return ComponentCfgBase.CreateFromDbEntity(typeof(QuidoRSCfg), component, this); + } + } +} diff --git a/TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRS.cs b/TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRS.cs new file mode 100644 index 000000000..4595a6098 --- /dev/null +++ b/TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRS.cs @@ -0,0 +1,83 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using System; +using System.Collections.Generic; +using log4net; +using TBF.BenchControl.Generic; +using TBF.Boxes; + +namespace TBF.BenchControl.Modbus.QuidoRS +{ + public class QuidoRS : ComponentBase + { + private static readonly ILog log = LogManager.GetLogger(typeof(QuidoRS)); + public override string ToString() { return string.Format("PressureMeter({0})", Cfg.ToString(1)); } + + readonly QuidoRSCfg quidoRSCfg; + + readonly GenericDevices.IModbus modbus; + + public QuidoRS() + { + } + + public QuidoRS(QuidoRSCfg cfg, IList components) + : base(cfg) + { + quidoRSCfg = cfg; + + modbus = (GenericDevices.IModbus)TbfComponents.FindComponent(cfg.ParentName, components); + if (modbus == null) throw new Exception("Cannot find " + Name + " parent"); + + /// Connect to handler + //ModbusAddress.MeretRS485Address[Idx0] = ModbusAddress; + + log.Debug(this.ToString()); + } + + + /// + /// Set outputs of QuidoRS board + /// + /// output value + public void SetOutputs(ushort outputs) + { + byte[] msg = new byte[11]; + + msg[0] = quidoRSCfg.ModbusAddress; + msg[1] = (byte)Function.ForceMultipleCoils; + msg[2] = 0; /// Data Hi + msg[3] = 0; /// Data Lo + msg[4] = 0; /// Nr. of coils Hi + msg[5] = 16; /// Nr. of coils Lo + msg[6] = 2; /// Byte count + msg[7] = (byte)(outputs & 0xFF); /// Output data Lo + msg[8] = (byte)(outputs >> 8); /// Output data Hi + + modbus.SendMessage(msg); + } + + + /// + /// Events: SetOpututsDone, Error + /// + /// Reference to a variable for the pressure in Bar + /// SetOutputsOp instance reference casted to IOperaton + public IOperation SetOutputsOp(ushort outValue) + { + return new SetOutputsOp(this, outValue); + } + + /// + /// Events: pressureDone, Error + /// + /// Reference to a variable for the pressure in Bar + /// Event returned when SetOutput is done + /// SetOutputsOp instance reference casted to IOperaton + public IOperation ReadPressureOp(ushort outValue, Event setOutputsDone) + { + return new SetOutputsOp(this, outValue, setOutputsDone); + } + } +} diff --git a/TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRSCfg.cs b/TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRSCfg.cs new file mode 100644 index 000000000..b59062230 --- /dev/null +++ b/TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRSCfg.cs @@ -0,0 +1,44 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using System; +using System.Collections.Generic; +using System.IO; +using System.Xml.Serialization; +using TBF.BenchControl.Generic; + +namespace TBF.BenchControl.Modbus.QuidoRS +{ + public class QuidoRSCfg : ComponentCfgBase, Generic.IChildComponentCfg + { + public IComponent GetComponent(IList components) { return new QuidoRS(this, components); } + public IComponentCfgCtrl GetControl() { return new QuidoRSCfgCtrl(); } + + /// + /// Serialized parameters + /// + public byte ModbusAddress; /// 1..255 + + /// Private parameterless constructor invoked by all other (public) constructors + QuidoRSCfg() + { + Name = "QuidoRS"; + ParentName = "Modbus"; + ModbusAddress = 49; + } + + public QuidoRSCfg(IComponentFactory factory) + : this() + { + this.Factory = factory; + } + + public string ToString(int i) + { + return string.Format("Name={0}, ModbusAddr={1}, Parent={2}", + Name, + ModbusAddress, + (string.IsNullOrEmpty(ParentName) ? "-" : ParentName)); + } + } +} diff --git a/TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRSCfgCtrl.cs b/TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRSCfgCtrl.cs new file mode 100644 index 000000000..7c4038f81 --- /dev/null +++ b/TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRSCfgCtrl.cs @@ -0,0 +1,106 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using System; +using System.Windows.Forms; +using log4net; +using TBF.BenchControl.Generic; + +namespace TBF.BenchControl.Modbus.QuidoRS +{ + public partial class QuidoRSCfgCtrl : UserControl, IComponentCfgCtrl + { + static readonly ILog log = LogManager.GetLogger(typeof(QuidoRSCfgCtrl)); + + ComponentParametersDlg parent; + + public bool ShowMore { get { return false; } } + + QuidoRSCfg config; + public IComponentCfg Config + { + get { return config as IComponentCfg; } + set + { + config = value as QuidoRSCfg; + Redraw(); + } + } + + public QuidoRSCfgCtrl() + { + InitializeComponent(); + } + + private void PressureMeterCfgCtrl_Load(object sender, EventArgs e) + { + parent = ParentForm as ComponentParametersDlg; + if (parent == null) return; + + if (parent.TbfComponents != null) + { + foreach (var cmpnt in parent.TbfComponents) + { + if (TbfComponents.CmpntFactoryFromClassName(cmpnt.ClassName) is Modbus.Common.Factory) + { + parentNameComboBox.Items.Add(cmpnt.Name); + } + } + } + + Redraw(); + } + + public void Closing() + { + } + + void Redraw() + { + if (config == null) return; /// Control was not loaded, settings were not changed + + componentNameLabel.Text = config.Factory.ClassName; + nameTextBox.Text = config.Name; + parentNameComboBox.Text = string.IsNullOrEmpty(config.ParentName) ? "---" : config.ParentName; + modbusAddressTextBox.Text = config.ModbusAddress.ToString(); + } + + public void Unlock() + { + nameTextBox.Enabled = true; + parentNameComboBox.Enabled = true; + modbusAddressTextBox.Enabled = true; + } + + public CfgUpdateFlags VerifyCfg(ref string message) + { + CfgUpdateFlags flags = CfgUpdateFlags.None; + + int dummy; + if (!parentNameComboBox.Items.Contains(parentNameComboBox.Text)) + { + flags |= CfgUpdateFlags.Error; + message += Environment.NewLine + "Invalid 'Parent Name'"; + } + if (!int.TryParse(modbusAddressTextBox.Text, out dummy) || dummy < 0 || dummy > 255) + { + flags |= CfgUpdateFlags.Error; + message += Environment.NewLine + "'Modbus Address' should be between 0 and 255"; + } + return flags; + } + + public CfgUpdateFlags UpdateCfg() + { + CfgUpdateFlags flags = CfgUpdateFlags.RestartRqrd; + + if (config == null) return CfgUpdateFlags.Error; /// Control was not loaded, settings were not changed + + config.Name = nameTextBox.Text; + config.ParentName = parentNameComboBox.Text.Equals("---") ? string.Empty : parentNameComboBox.Text; + config.ModbusAddress = (byte)int.Parse(modbusAddressTextBox.Text); + + return flags; + } + } +} diff --git a/TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRSCfgCtrl.designer.cs b/TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRSCfgCtrl.designer.cs new file mode 100644 index 000000000..e1740d9d5 --- /dev/null +++ b/TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRSCfgCtrl.designer.cs @@ -0,0 +1,133 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +namespace TBF.BenchControl.Modbus.QuidoRS +{ + partial class QuidoRSCfgCtrl + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Component Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.parentNameLabel = new System.Windows.Forms.Label(); + this.nameTextBox = new System.Windows.Forms.TextBox(); + this.nameLabel = new System.Windows.Forms.Label(); + this.componentNameLabel = new System.Windows.Forms.Label(); + this.modbusAddressLabel = new System.Windows.Forms.Label(); + this.modbusAddressTextBox = new System.Windows.Forms.TextBox(); + this.parentNameComboBox = new System.Windows.Forms.ComboBox(); + this.SuspendLayout(); + // + // parentNameLabel + // + this.parentNameLabel.AutoSize = true; + this.parentNameLabel.Location = new System.Drawing.Point(28, 81); + this.parentNameLabel.Name = "parentNameLabel"; + this.parentNameLabel.Size = new System.Drawing.Size(69, 13); + this.parentNameLabel.TabIndex = 3; + this.parentNameLabel.Text = "Parent Name"; + // + // nameTextBox + // + this.nameTextBox.Enabled = false; + this.nameTextBox.Location = new System.Drawing.Point(138, 52); + this.nameTextBox.Name = "nameTextBox"; + this.nameTextBox.Size = new System.Drawing.Size(130, 20); + this.nameTextBox.TabIndex = 2; + // + // nameLabel + // + this.nameLabel.AutoSize = true; + this.nameLabel.Location = new System.Drawing.Point(28, 55); + this.nameLabel.Name = "nameLabel"; + this.nameLabel.Size = new System.Drawing.Size(35, 13); + this.nameLabel.TabIndex = 1; + this.nameLabel.Text = "Name"; + // + // componentNameLabel + // + this.componentNameLabel.AutoSize = true; + this.componentNameLabel.Location = new System.Drawing.Point(135, 28); + this.componentNameLabel.Name = "componentNameLabel"; + this.componentNameLabel.Size = new System.Drawing.Size(83, 13); + this.componentNameLabel.TabIndex = 0; + this.componentNameLabel.Text = "ComonentName"; + // + // modbusAddressLabel + // + this.modbusAddressLabel.AutoSize = true; + this.modbusAddressLabel.Location = new System.Drawing.Point(28, 133); + this.modbusAddressLabel.Name = "modbusAddressLabel"; + this.modbusAddressLabel.Size = new System.Drawing.Size(86, 13); + this.modbusAddressLabel.TabIndex = 7; + this.modbusAddressLabel.Text = "Modbus Address"; + // + // modbusAddressTextBox + // + this.modbusAddressTextBox.Enabled = false; + this.modbusAddressTextBox.Location = new System.Drawing.Point(138, 130); + this.modbusAddressTextBox.Name = "modbusAddressTextBox"; + this.modbusAddressTextBox.Size = new System.Drawing.Size(46, 20); + this.modbusAddressTextBox.TabIndex = 8; + // + // parentNameComboBox + // + this.parentNameComboBox.Enabled = false; + this.parentNameComboBox.FormattingEnabled = true; + this.parentNameComboBox.Location = new System.Drawing.Point(138, 78); + this.parentNameComboBox.Name = "parentNameComboBox"; + this.parentNameComboBox.Size = new System.Drawing.Size(130, 21); + this.parentNameComboBox.TabIndex = 4; + // + // ComponentCfgCtrl + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Controls.Add(this.parentNameComboBox); + this.Controls.Add(this.modbusAddressTextBox); + this.Controls.Add(this.modbusAddressLabel); + this.Controls.Add(this.parentNameLabel); + this.Controls.Add(this.nameTextBox); + this.Controls.Add(this.nameLabel); + this.Controls.Add(this.componentNameLabel); + this.Name = "ComponentCfgCtrl"; + this.Size = new System.Drawing.Size(300, 200); + this.Load += new System.EventHandler(this.PressureMeterCfgCtrl_Load); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Label parentNameLabel; + private System.Windows.Forms.TextBox nameTextBox; + private System.Windows.Forms.Label nameLabel; + private System.Windows.Forms.Label componentNameLabel; + private System.Windows.Forms.Label modbusAddressLabel; + private System.Windows.Forms.TextBox modbusAddressTextBox; + private System.Windows.Forms.ComboBox parentNameComboBox; + } +} diff --git a/TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRSCfgCtrl.resx b/TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRSCfgCtrl.resx new file mode 100644 index 000000000..1af7de150 --- /dev/null +++ b/TestBenchFramework/BenchControl/Modbus/QuidoRS/QuidoRSCfgCtrl.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/TestBenchFramework/BenchControl/Modbus/QuidoRS/SetOutputsOp.cs b/TestBenchFramework/BenchControl/Modbus/QuidoRS/SetOutputsOp.cs new file mode 100644 index 000000000..6546db0be --- /dev/null +++ b/TestBenchFramework/BenchControl/Modbus/QuidoRS/SetOutputsOp.cs @@ -0,0 +1,57 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using System; +using log4net; +using TBF.Boxes; + +namespace TBF.BenchControl.Modbus.QuidoRS +{ + public class SetOutputsOp : IOperation + { + private static readonly ILog log = LogManager.GetLogger(typeof(SetOutputsOp)); + public override string ToString() { return string.Format("SetOutputsOp(.,{0},{1})", outValue, eventDone); } + + /// Set by the constructor + readonly QuidoRS quidoRS; + readonly Event eventDone; + ushort outValue; + + /// + /// Events: PressureInDone, PressureOutDone or Error + /// + /// Pressure meter reference + /// Reference to the measured pressure variable, value is in bar + /// Event to be returned by Run() when completed OK + public SetOutputsOp(QuidoRS quidoRS, ushort outValue, Event eventDone) + { + if (quidoRS == null) throw new ArgumentNullException("quidoRS"); + this.quidoRS = quidoRS; + this.outValue = outValue; + this.eventDone = eventDone; + + log.Debug(this.ToString()); + } + public SetOutputsOp(QuidoRS quidoRS, ushort outValue) + : this(quidoRS, outValue, Event.SetOutputsDone) + { + } + + /// Start this operation + public void Start() + { + quidoRS.SetOutputs(outValue); + } + + /// Run this operation + public Event Run() + { + return eventDone; + } + + /// Stop this operation + public void Stop() + { + } + } +} diff --git a/TestBenchFramework/BenchControl/TbfComponents.cs b/TestBenchFramework/BenchControl/TbfComponents.cs index 21524c22f..3b4f7d616 100644 --- a/TestBenchFramework/BenchControl/TbfComponents.cs +++ b/TestBenchFramework/BenchControl/TbfComponents.cs @@ -39,10 +39,13 @@ namespace TBF.BenchControl Factories.Add(new Ambient.Comet.Factory()); Factories.Add(new Ambient.Greco.Factory()); Factories.Add(new Cameras.IdcCamera.IdcCameraFactory()); - Factories.Add(new TestMethods.LeakTest.TestMethodFactory()); - Factories.Add(new MettlerToledo.Standard.BalanceFactory()); - Factories.Add(new MettlerToledo.Standard.BalanceNewFactory()); - Factories.Add(new MettlerToledo.Multi.BalanceFactory()); + Factories.Add(new WaterMeters.iPerl.WaterMeterFactory()); /// iPerl + Factories.Add(new TestMethods.iPerlAdjustment.TestMethodFactory()); /// iPerlAdjustment + Factories.Add(new TestMethods.LeakTest.TestMethodFactory()); + Factories.Add(new MettlerToledo.Standard.BalanceFactory()); /// MettlerToledo Balance + Factories.Add(new MettlerToledo.Standard.BalanceNewFactory()); /// MettlerToledoBalanceSN + Factories.Add(new MettlerToledo.Multi.BalanceFactory()); /// MettlerToledo-Multi + Factories.Add(new Modbus.Common.Factory()); /// Modbus Factories.Add(new TestMethods.PMaxTest.TestMethodFactory()); Factories.Add(new Elde.PressureMeter.PressureMeterFactory()); Factories.Add(new Elde.PressureMeterInternal.PressureMeterFactory()); @@ -50,6 +53,7 @@ namespace TBF.BenchControl Factories.Add(new Danfoss.VLT2800.PumpFactory()); Factories.Add(new Elde.PumpWithFM.PumpFactory()); Factories.Add(new Elde.PumpTandem.PumpFactory()); + Factories.Add(new Modbus.QuidoRS.Factory()); /// QuidoRS Factories.Add(new TestMethods.ReferenceFlowmeterCalibration.TestMethodFactory()); Factories.Add(new Elde.RegisterReader.RegisterReaderFactory()); Factories.Add(new Elde.RegulValve.RegulValveFactory()); @@ -60,7 +64,7 @@ namespace TBF.BenchControl Factories.Add(new Elde.TempMeterInternal.TempMeterFactory()); Factories.Add(new Elde.Valve.ValveFactory()); Factories.Add(new Elde.ValveEx.ValveFactory()); - Factories.Add(new WaterMeter.WaterMeterFactory()); + Factories.Add(new WaterMeters.WaterMeter.WaterMeterFactory()); /// WaterMeter } /// diff --git a/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethod.cs b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethod.cs new file mode 100644 index 000000000..0b5e7997f --- /dev/null +++ b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethod.cs @@ -0,0 +1,35 @@ +/// +/// Copyright (c) 2013-2015 Sensus Metering Systems +/// +using System; +using System.Collections.Generic; +using log4net; +using TBF.BenchControl; + +namespace TBF.BenchControl.TestMethods.iPerlAdjustment +{ + public class TestMethod : ComponentBase, GenericDevices.ITestMethod + { + private static readonly ILog log = LogManager.GetLogger(typeof(TestMethod)); + public override string ToString() { return string.Format("TestMethods.Adjustment({0})", Cfg.ToString(1)); } + + public bool Evaluate { get { return false; } } + public bool Publish { get { return false; } } + public bool CanTest(Entities.MetersKind meters) { return meters == Entities.MetersKind.Single; } + + public TestMethod() + { + } + + public TestMethod(TestMethodCfg cfg) + : base(cfg) + { + log.Debug(this.ToString()); + } + + public IList Execute(Entities.Test test) + { + return (new iPerlAdjustmentSeq()).Execute(test); + } + } +} diff --git a/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodCfg.cs b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodCfg.cs new file mode 100644 index 000000000..63be1f92c --- /dev/null +++ b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodCfg.cs @@ -0,0 +1,35 @@ +/// +/// Copyright (c) 2013-2015 Sensus Metering Systems +/// +using System; +using System.Collections.Generic; +using System.IO; +using System.Xml.Serialization; +using TBF.BenchControl.Generic; + +namespace TBF.BenchControl.TestMethods.iPerlAdjustment +{ + public class TestMethodCfg : ComponentCfgBase, Generic.IComponentCfg + { + public IComponent GetComponent(IList components) { return new TestMethod(this); } + public IComponentCfgCtrl GetControl() { return new TestMethodCfgCtrl(); } + + /// Private parameterless constructor invoked by all other (public) constructors + TestMethodCfg() + { + Name = "Adjustment"; + ParentName = string.Empty; + } + + public TestMethodCfg(IComponentFactory factory) + : this() + { + this.Factory = factory; + } + + public string ToString(int i) + { + return string.Format("Name={0}", Name); + } + } +} diff --git a/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodCfgCtrl.cs b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodCfgCtrl.cs new file mode 100644 index 000000000..04afe36d0 --- /dev/null +++ b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodCfgCtrl.cs @@ -0,0 +1,71 @@ +/// +/// Copyright (c) 2013-2015 Sensus Metering Systems +/// +using System; +using System.Windows.Forms; +using log4net; +using TBF.BenchControl.Generic; + +namespace TBF.BenchControl.TestMethods.iPerlAdjustment +{ + public partial class TestMethodCfgCtrl : UserControl, IComponentCfgCtrl + { + static readonly ILog log = LogManager.GetLogger(typeof(TestMethodCfgCtrl)); + + public bool ShowMore { get { return false; } } + + TestMethodCfg config; + public IComponentCfg Config + { + get { return config as IComponentCfg; } + set + { + config = value as TestMethodCfg; + Redraw(); + } + } + + public TestMethodCfgCtrl() + { + InitializeComponent(); + } + + private void EntryFormCfgCtrl_Load(object sender, EventArgs e) + { + Redraw(); + } + + public void Closing() + { + } + + void Redraw() + { + if (config == null) return; /// Control was not loaded, settings were not changed + classNameLabel.Text = config.Factory.ClassName; + nameTextBox.Text = config.Name; + } + + public void Unlock() + { + nameTextBox.Enabled = true; + } + + public CfgUpdateFlags VerifyCfg(ref string message) + { + CfgUpdateFlags flags = CfgUpdateFlags.None; + return flags; + } + + public CfgUpdateFlags UpdateCfg() + { + CfgUpdateFlags flags = CfgUpdateFlags.RestartRqrd; + + if (config == null) return CfgUpdateFlags.Error; /// Control was not loaded, settings were not changed + + config.Name = nameTextBox.Text; + + return flags; + } + } +} diff --git a/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodCfgCtrl.designer.cs b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodCfgCtrl.designer.cs new file mode 100644 index 000000000..64e6ff4f7 --- /dev/null +++ b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodCfgCtrl.designer.cs @@ -0,0 +1,86 @@ +/// +/// Copyright (c) 2013-2015 Sensus Metering Systems +/// +namespace TBF.BenchControl.TestMethods.iPerlAdjustment +{ + partial class TestMethodCfgCtrl + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Component Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.nameTextBox = new System.Windows.Forms.TextBox(); + this.nameLabel = new System.Windows.Forms.Label(); + this.classNameLabel = new System.Windows.Forms.Label(); + this.SuspendLayout(); + // + // nameTextBox + // + this.nameTextBox.Enabled = false; + this.nameTextBox.Location = new System.Drawing.Point(137, 57); + this.nameTextBox.Name = "nameTextBox"; + this.nameTextBox.Size = new System.Drawing.Size(130, 20); + this.nameTextBox.TabIndex = 5; + // + // nameLabel + // + this.nameLabel.AutoSize = true; + this.nameLabel.Location = new System.Drawing.Point(27, 60); + this.nameLabel.Name = "nameLabel"; + this.nameLabel.Size = new System.Drawing.Size(35, 13); + this.nameLabel.TabIndex = 4; + this.nameLabel.Text = "Name"; + // + // classNameLabel + // + this.classNameLabel.AutoSize = true; + this.classNameLabel.Location = new System.Drawing.Point(134, 33); + this.classNameLabel.Name = "classNameLabel"; + this.classNameLabel.Size = new System.Drawing.Size(83, 13); + this.classNameLabel.TabIndex = 3; + this.classNameLabel.Text = "ComonentName"; + // + // BasicPrinterCfgCtrl + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Controls.Add(this.nameTextBox); + this.Controls.Add(this.nameLabel); + this.Controls.Add(this.classNameLabel); + this.Name = "BasicPrinterCfgCtrl"; + this.Size = new System.Drawing.Size(300, 200); + this.Load += new System.EventHandler(this.EntryFormCfgCtrl_Load); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.TextBox nameTextBox; + private System.Windows.Forms.Label nameLabel; + private System.Windows.Forms.Label classNameLabel; + } +} diff --git a/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodCfgCtrl.resx b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodCfgCtrl.resx new file mode 100644 index 000000000..1af7de150 --- /dev/null +++ b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodCfgCtrl.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodFactory.cs b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodFactory.cs new file mode 100644 index 000000000..dd54cef06 --- /dev/null +++ b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/TestMethodFactory.cs @@ -0,0 +1,23 @@ +/// +/// Copyright (c) 2013-2015 Sensus Metering Systems +/// +using TBF.BenchControl.Generic; + +namespace TBF.BenchControl.TestMethods.iPerlAdjustment +{ + public class TestMethodFactory : IComponentFactory + { + public string ClassName { get { return "iPerlAdjustment"; } } + + public void ResetStaticProperties() { TestMethod.ResetStaticProperties(); } + + public IComponent DummyComponent() { return new TestMethod(); } + + public IComponentCfg DefaultConfig() { return new TestMethodCfg(this); } + + public IComponentCfg CmpntCfgFromCmpntEntity(Entities.Component component) + { + return ComponentCfgBase.CreateFromDbEntity(typeof(TestMethodCfg), component, this); + } + } +} diff --git a/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/iPerlAdjustmentSeq.cs b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/iPerlAdjustmentSeq.cs new file mode 100644 index 000000000..b00d24b5b --- /dev/null +++ b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/iPerlAdjustmentSeq.cs @@ -0,0 +1,127 @@ +/// +/// Copyright (c) 2013-2015 Sensus Metering Systems +/// +using System; +using System.Collections.Generic; +using System.Text; +using log4net; +using TBF.BenchControl; +using TBF.Boxes; +using TBF.Resources; +using TBF.UiBridge; + +namespace TBF.BenchControl.TestMethods.iPerlAdjustment +{ + public class iPerlAdjustmentSeq : Sequences.SequenceBase + { + private static readonly ILog log = LogManager.GetLogger(typeof(iPerlAdjustmentSeq)); + + System.Windows.Forms.Form modelessDlg; + /// + delegate void ErrorsFormDlgt(iPerlAdjustmentSeq myRef); + /// + void OpenWMErrorsForm(iPerlAdjustmentSeq myRef) + { + myRef.modelessDlg = new iPerlCommunicationForm(Program.WMsCount); + modelessDlg.Show(); + } + + /// + /// Flying start mass collection method sequence + /// + /// Test entity + /// + /// Event.Done . . . . . . . OK + /// Event.UiCmdStop . . . . Stopped by the user using the on-screen button STOP + /// Event.OpArgumentError . Target flow is out of range + /// Event.Error . . . . . . Unspecified error + /// + public IList Execute(Entities.Test test) + { + + Elde.ControlBoardDev cBrd = StateMachine.ControlBoard; + + IList e = new List(); /// Events from currently running operations + Event retVal = Event.Done; + checkUiOp = new Operations.CheckUIOp(true); /// Runs in more then one state + + ltrPerRefPulse = outPath.FlowMeter.LtrPerPulse; /// [ltr/pulse], nominal flow in [m3/h] + + /// Notes: + /// float timeHr = volumeLtr / (1000.0f * targetFlow); + /// float timeSec = 3600.0f * timeHr; + /// int refPulses = (int)(timeSec * (2000.0f * targetFlow / pOut.FlowMeter.NominalFlow)); + int totalPulses = (int)(test.Volume / ltrPerRefPulse + 0.5f); + + processDataLoggingOp = new TBF.BenchControl.Operations.ProcessDataLoggingOp(processDataLogger, this); + + int repetitionNr = 1; /// First test: repetitionNr=1 + + //==================================== + // Transition or SetRoute - Start + //==================================== + switch (Transition(transitionBefore, TransitionContext.BeforeTest)) + { + case Event.Error: { retVal = Event.Error; goto stopTest; } + case Event.UiCmdStop: { retVal = Event.UiCmdStop; goto stopTest; } + } + + /// Start the test, initialize test results + Bridge.OnTestSelected(this, new TestSelectedEventArgs(test, repetitionNr, inPath, benchPath, outPath, sensPath, totalPulses)); + Entities.TestResult tstRslt = new Entities.TestResult(test, repetitionNr, Entities.MetersKind.Single); + tstRslt.DoNotEvaluate = true; + tstRslt.DoNotPublish = true; + + /// + /// Show the modeless dialog with error indication + /// + Program.MainWnd.Invoke(new ErrorsFormDlgt(OpenWMErrorsForm), this); + + loop: + + //------------------------------------------------ + Bridge.OnActivity(this, Strings.Test_in_progress); + //------------------------------------------------ + + /// Make sure the CycleBeginForm is closed so that water meter data (s/n) can be copied into results + if (UIFlowControl.Stop == WaitBeginFormClosed()) goto stopTest; + + /// Test 'Quit' + if ((modelessDlg is GenericDevices.IHasCompleted) && !(modelessDlg as GenericDevices.IHasCompleted).Completed) + { + goto loop; /// Modeless dilaog not closed, keep looping + } + modelessDlg = null; /// Modeless dialog is closed now + + stopTest: + + ///----------------------/// + /// Quit this sequence /// + ///----------------------/// + + State.Create("Adjustment : Stopping diverter, gate, etc.") + .AddOperation(checkUiOp) + .AddOperation(cBrd.StopPreviousOp()) + .EnterState(); + do + { + e = StateMachine.WaitRunDevsRunOps(); + if (e.Contains(Event.UiCmdStop)) { retVal = Event.UiCmdStop; goto stopTest; } + } + while (!e.Contains(Event.PreviousStopped)); + + /// Transition sequence at the end of test + /// Prevent overwriting 'retVal' in case it was set to non-default value earlier + switch (Transition(transitionAfter, TransitionContext.AfterTest)) + { + case Event.Error: { if (retVal == Event.Done) retVal = Event.Error; break; } + case Event.UiCmdStop: { if (retVal == Event.Done) retVal = Event.UiCmdStop; break; } + } + + /// Create a list with one item 'retVal' (default is Event.Done) and return it + IList retList = new List(1); + retList.Add(retVal); + return retList; + } + } +} diff --git a/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/iPerlCommunicationForm.cs b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/iPerlCommunicationForm.cs new file mode 100644 index 000000000..b1847f42e --- /dev/null +++ b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/iPerlCommunicationForm.cs @@ -0,0 +1,266 @@ +/// +/// Copyright (c) 2013-2015 Sensus Metering Systems +/// +using System; +using System.Drawing; +using System.Windows.Forms; +using log4net; +using TBF.Resources; + +namespace TBF.BenchControl.TestMethods.iPerlAdjustment +{ + public partial class iPerlCommunicationForm : Form, GenericDevices.IHasCompleted + { + private static readonly ILog log = LogManager.GetLogger(typeof(iPerlCommunicationForm)); + + // Set to 'true' when the form closes + public bool Completed { get { return completed; } } + bool completed; + + /// Number of text boxes for serial numbers + public readonly int WaterMetersCount; + + readonly bool[] disabled; + + Entities.TestResult tr; + + int textBoxesCount; + + Label[] labels; + TextBox[] errors; + + + /// Parameterless constructor for 3 watermeters + public iPerlCommunicationForm() + { + InitializeComponent(); + + textBoxesCount = 48; + + labels = new Label[48] + { + wmErrorLabel1, wmErrorLabel2, wmErrorLabel3, wmErrorLabel4, wmErrorLabel5, + wmErrorLabel6, wmErrorLabel7, wmErrorLabel8, wmErrorLabel9, wmErrorLabel10, + wmErrorLabel11, wmErrorLabel12, wmErrorLabel13, wmErrorLabel14, wmErrorLabel15, + wmErrorLabel16, wmErrorLabel17, wmErrorLabel18, wmErrorLabel19, wmErrorLabel20, + wmErrorLabel21, wmErrorLabel22, wmErrorLabel23, wmErrorLabel24, wmErrorLabel25, + wmErrorLabel26, wmErrorLabel27, wmErrorLabel28, wmErrorLabel29, wmErrorLabel30, + wmErrorLabel31, wmErrorLabel32, wmErrorLabel33, wmErrorLabel34, wmErrorLabel35, + wmErrorLabel36, wmErrorLabel37, wmErrorLabel38, wmErrorLabel39, wmErrorLabel40, + wmErrorLabel41, wmErrorLabel42, wmErrorLabel43, wmErrorLabel44, wmErrorLabel45, + wmErrorLabel46, wmErrorLabel47, wmErrorLabel48, + }; + errors = new TextBox[48] + { + wmErrorTextBox1, wmErrorTextBox2, wmErrorTextBox3, wmErrorTextBox4, wmErrorTextBox5, + wmErrorTextBox6, wmErrorTextBox7, wmErrorTextBox8, wmErrorTextBox9, wmErrorTextBox10, + wmErrorTextBox11, wmErrorTextBox12, wmErrorTextBox13, wmErrorTextBox14, wmErrorTextBox15, + wmErrorTextBox16, wmErrorTextBox17, wmErrorTextBox18, wmErrorTextBox19, wmErrorTextBox20, + wmErrorTextBox21, wmErrorTextBox22, wmErrorTextBox23, wmErrorTextBox24, wmErrorTextBox25, + wmErrorTextBox26, wmErrorTextBox27, wmErrorTextBox28, wmErrorTextBox29, wmErrorTextBox30, + wmErrorTextBox31, wmErrorTextBox32, wmErrorTextBox33, wmErrorTextBox34, wmErrorTextBox35, + wmErrorTextBox36, wmErrorTextBox37, wmErrorTextBox38, wmErrorTextBox39, wmErrorTextBox40, + wmErrorTextBox41, wmErrorTextBox42, wmErrorTextBox43, wmErrorTextBox44, wmErrorTextBox45, + wmErrorTextBox46, wmErrorTextBox47, wmErrorTextBox48, + }; + + //rects = new Rectangle[48]; + //for (int i = 0; i < 48; i++) + //{ + // int row = i % 12; + // int col = i / 12; + // rects[i] = new Rectangle(350 + col * 557, 25 + row * 47, 230, 37); + //} + + completed = false; + tr = null; + + /// Attach to 'AdjustmentInProgress' handler + UiBridge.Bridge.AdjustmentInProgressHandler += delegate(object sender, UiBridge.AdjustmentInProgressEventArgs args) + { + if (InvokeRequired) + { + Invoke(new EventHandler(OnAdjustmentInProgress), sender, args); + } + else OnAdjustmentInProgress(sender, args); + }; + } + + /// + /// Constructor + /// + /// Number of text boxes for serial numbers + public iPerlCommunicationForm(int waterMetersCount) + : this() + { + this.WaterMetersCount = waterMetersCount; + + ShuffleTextBoxes(waterMetersCount, Program.LineSize); + + disabled = new bool[waterMetersCount]; + } + + + /// + /// Make sure the layout of labels/text boxes on the screen + /// corresponds to the layout of watermeters of the test bench. + /// + /// Number of watermeters + /// Number of watermeters in one line + void ShuffleTextBoxes(int wmsCount, int lineSize) + { + if (wmsCount < textBoxesCount && lineSize > 0) + { + int nrLines = (wmsCount + lineSize - 1) / lineSize; + int gap = (textBoxesCount - wmsCount) / nrLines; + + int dest = 0; + for (int l = 0; l < nrLines; l++) + { + for (int i = 0; i < lineSize; i++) + { + labels[dest] = labels[l * lineSize + l * gap + i]; + errors[dest] = errors[l * lineSize + l * gap + i]; + dest++; + } + } + textBoxesCount = wmsCount; + } + } + + + void Localize() + { + Text = Strings.Water_Meter_States; + for (int i = 0; i < textBoxesCount; i++) + { + labels[i].Text = string.Format("WM{0} {1}", i + 1, Strings.Error_pct); + } + okButton.Text = Strings.OkBtnText; + } + + private void WMErrorsForm24_Load(object sender, EventArgs e) + { + Localize(); + + //Height = 50 + 90 * WaterMetersCount; + + for (int i = 0; i < textBoxesCount; i++) + { + if (disabled != null && i < disabled.Length && disabled[i]) + { + labels[i].Visible = errors[i].Visible = false; + } + else + { + labels[i].Visible = errors[i].Visible = true; + errors[i].Text = "---"; + } + } + } + + private void okButton_Click(object sender, EventArgs e) + { + completed = true; + Close(); + } + + void OnAdjustmentInProgress(object sender, UiBridge.AdjustmentInProgressEventArgs args) + { + tr = args.TestResult; + Redraw(); + } + + void Redraw() + { + if (tr != null) + { + for (int i = 0; i < textBoxesCount; i++) + { + errors[i].Text = tr.Meters[i].VolumeErrorPct.ToString("F1"); + } + } + } + + private void WMErrorsForm_Paint(object sender, PaintEventArgs e) + { + //if (tr != null) + //{ + // System.Drawing.Graphics graphics = this.CreateGraphics(); + + // for (int i = 0; i < WaterMetersCount; i++) + // { + // PaintOne(graphics, rects[i], tr.Meters[i].VolumeErrorPct, tr.ErrLimLo, tr.ErrLimHi); + // } + //} + } + + void PaintOne(System.Drawing.Graphics g, Rectangle r, float value, float limLo, float limHi) + { + Rectangle rect1 = new Rectangle(r.Left, r.Top, r.Width / 3, r.Height); + Rectangle rect2 = new Rectangle(r.Left + r.Width / 3, r.Top, r.Width / 3, r.Height); + Rectangle rect3 = new Rectangle(r.Left + 2 * (r.Width / 3), r.Top, r.Width / 3, r.Height); + Rectangle rectCent = new Rectangle(r.Left + r.Width / 2 - 1, r.Top, 3, r.Height); + + Brush redBrush = new SolidBrush(Color.FromName("Salmon")); + Brush greenBrush = new SolidBrush(Color.FromName("LightGreen")); + Brush centBrush = new SolidBrush(Color.FromName("Green")); + + g.FillRectangle(redBrush, rect1); + g.FillRectangle(greenBrush, rect2); + g.FillRectangle(redBrush, rect3); + g.FillRectangle(centBrush, rectCent); + + int x0 = r.Left + r.Width / 2; + int dx = r.Height / 3; + int x = (int)((float)r.Width * (2.0 * value - limLo - limHi) / (limHi - limLo) / 6.0f + 0.5f); + + if (x0 - dx + x >= r.Left && x0 + dx + x < r.Left + r.Width) + { + Point[] triangle = new Point[3] + { + new Point(x0 - dx + x, r.Top), + new Point(x0 + dx + x, r.Top), + new Point(x0 + x, r.Top + 2 * r.Height / 3), + }; + + Brush blackBrush = new SolidBrush(Color.Black); + g.FillPolygon(blackBrush, triangle); + } + } + + #region Forced close handling + + public void StartForceCloseHandler() + { + UiBridge.Bridge.CloseModelessFormHandler += delegate(object sender, EventArgs args) + { + if (InvokeRequired) { Invoke(new EventHandler(OnForceClose), sender, args); } + else OnForceClose(sender, args); + }; + } + + void OnForceClose(object sender, EventArgs args) + { + DialogResult = DialogResult.Cancel; + Close(); + } + + #endregion + + private void readConfigBtn_Click(object sender, EventArgs e) + { + + } + + private void toTestMdBtn_Click(object sender, EventArgs e) + { + + } + + private void toActiveMdBtn_Click(object sender, EventArgs e) + { + + } + } +} diff --git a/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/iPerlCommunicationForm.designer.cs b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/iPerlCommunicationForm.designer.cs new file mode 100644 index 000000000..39c5f1e10 --- /dev/null +++ b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/iPerlCommunicationForm.designer.cs @@ -0,0 +1,1366 @@ +/// +/// Copyright (c) 2013-2015 Sensus Metering Systems +/// +namespace TBF.BenchControl.TestMethods.iPerlAdjustment +{ + partial class iPerlCommunicationForm + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.wmErrorTextBox2 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel2 = new System.Windows.Forms.Label(); + this.wmErrorLabel1 = new System.Windows.Forms.Label(); + this.okButton = new System.Windows.Forms.Button(); + this.wmErrorTextBox3 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel3 = new System.Windows.Forms.Label(); + this.wmErrorTextBox4 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel4 = new System.Windows.Forms.Label(); + this.wmErrorTextBox5 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel5 = new System.Windows.Forms.Label(); + this.wmErrorTextBox6 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel6 = new System.Windows.Forms.Label(); + this.wmErrorTextBox1 = new System.Windows.Forms.TextBox(); + this.wmErrorTextBox7 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel7 = new System.Windows.Forms.Label(); + this.wmErrorTextBox8 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel8 = new System.Windows.Forms.Label(); + this.wmErrorTextBox9 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel9 = new System.Windows.Forms.Label(); + this.wmErrorTextBox10 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel10 = new System.Windows.Forms.Label(); + this.wmErrorTextBox12 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel12 = new System.Windows.Forms.Label(); + this.wmErrorTextBox11 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel11 = new System.Windows.Forms.Label(); + this.wmErrorTextBox24 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel24 = new System.Windows.Forms.Label(); + this.wmErrorTextBox23 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel23 = new System.Windows.Forms.Label(); + this.wmErrorTextBox22 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel22 = new System.Windows.Forms.Label(); + this.wmErrorTextBox21 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel21 = new System.Windows.Forms.Label(); + this.wmErrorTextBox20 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel20 = new System.Windows.Forms.Label(); + this.wmErrorTextBox19 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel19 = new System.Windows.Forms.Label(); + this.wmErrorTextBox18 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel18 = new System.Windows.Forms.Label(); + this.wmErrorTextBox17 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel17 = new System.Windows.Forms.Label(); + this.wmErrorTextBox16 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel16 = new System.Windows.Forms.Label(); + this.wmErrorTextBox15 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel15 = new System.Windows.Forms.Label(); + this.wmErrorTextBox14 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel14 = new System.Windows.Forms.Label(); + this.wmErrorTextBox13 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel13 = new System.Windows.Forms.Label(); + this.toTestMdBtn = new System.Windows.Forms.Button(); + this.toActiveMdBtn = new System.Windows.Forms.Button(); + this.readConfigBtn = new System.Windows.Forms.Button(); + this.wmErrorTextBox48 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel48 = new System.Windows.Forms.Label(); + this.wmErrorTextBox47 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel47 = new System.Windows.Forms.Label(); + this.wmErrorTextBox46 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel46 = new System.Windows.Forms.Label(); + this.wmErrorTextBox45 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel45 = new System.Windows.Forms.Label(); + this.wmErrorTextBox44 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel44 = new System.Windows.Forms.Label(); + this.wmErrorTextBox43 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel43 = new System.Windows.Forms.Label(); + this.wmErrorTextBox42 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel42 = new System.Windows.Forms.Label(); + this.wmErrorTextBox41 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel41 = new System.Windows.Forms.Label(); + this.wmErrorTextBox40 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel40 = new System.Windows.Forms.Label(); + this.wmErrorTextBox39 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel39 = new System.Windows.Forms.Label(); + this.wmErrorTextBox38 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel38 = new System.Windows.Forms.Label(); + this.wmErrorTextBox37 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel37 = new System.Windows.Forms.Label(); + this.wmErrorTextBox36 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel36 = new System.Windows.Forms.Label(); + this.wmErrorTextBox35 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel35 = new System.Windows.Forms.Label(); + this.wmErrorTextBox34 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel34 = new System.Windows.Forms.Label(); + this.wmErrorTextBox33 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel33 = new System.Windows.Forms.Label(); + this.wmErrorTextBox32 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel32 = new System.Windows.Forms.Label(); + this.wmErrorTextBox31 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel31 = new System.Windows.Forms.Label(); + this.wmErrorTextBox30 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel30 = new System.Windows.Forms.Label(); + this.wmErrorTextBox29 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel29 = new System.Windows.Forms.Label(); + this.wmErrorTextBox28 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel28 = new System.Windows.Forms.Label(); + this.wmErrorTextBox27 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel27 = new System.Windows.Forms.Label(); + this.wmErrorTextBox26 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel26 = new System.Windows.Forms.Label(); + this.wmErrorTextBox25 = new System.Windows.Forms.TextBox(); + this.wmErrorLabel25 = new System.Windows.Forms.Label(); + this.SuspendLayout(); + // + // wmErrorTextBox2 + // + this.wmErrorTextBox2.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox2.Location = new System.Drawing.Point(198, 57); + this.wmErrorTextBox2.Name = "wmErrorTextBox2"; + this.wmErrorTextBox2.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox2.TabIndex = 1; + this.wmErrorTextBox2.Visible = false; + // + // wmErrorLabel2 + // + this.wmErrorLabel2.AutoSize = true; + this.wmErrorLabel2.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel2.Location = new System.Drawing.Point(33, 63); + this.wmErrorLabel2.Name = "wmErrorLabel2"; + this.wmErrorLabel2.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel2.TabIndex = 0; + this.wmErrorLabel2.Text = "Error [%]"; + this.wmErrorLabel2.Visible = false; + // + // wmErrorLabel1 + // + this.wmErrorLabel1.AutoSize = true; + this.wmErrorLabel1.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel1.Location = new System.Drawing.Point(33, 34); + this.wmErrorLabel1.Name = "wmErrorLabel1"; + this.wmErrorLabel1.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel1.TabIndex = 0; + this.wmErrorLabel1.Text = "Error [%]"; + this.wmErrorLabel1.Visible = false; + // + // okButton + // + this.okButton.Font = new System.Drawing.Font("Verdana", 14.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.okButton.ForeColor = System.Drawing.Color.Black; + this.okButton.Location = new System.Drawing.Point(1157, 28); + this.okButton.Name = "okButton"; + this.okButton.Size = new System.Drawing.Size(98, 63); + this.okButton.TabIndex = 7; + this.okButton.Text = "Close"; + this.okButton.UseVisualStyleBackColor = true; + this.okButton.Click += new System.EventHandler(this.okButton_Click); + // + // wmErrorTextBox3 + // + this.wmErrorTextBox3.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox3.Location = new System.Drawing.Point(198, 86); + this.wmErrorTextBox3.Name = "wmErrorTextBox3"; + this.wmErrorTextBox3.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox3.TabIndex = 1; + this.wmErrorTextBox3.Visible = false; + // + // wmErrorLabel3 + // + this.wmErrorLabel3.AutoSize = true; + this.wmErrorLabel3.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel3.Location = new System.Drawing.Point(33, 92); + this.wmErrorLabel3.Name = "wmErrorLabel3"; + this.wmErrorLabel3.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel3.TabIndex = 0; + this.wmErrorLabel3.Text = "Error [%]"; + this.wmErrorLabel3.Visible = false; + // + // wmErrorTextBox4 + // + this.wmErrorTextBox4.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox4.Location = new System.Drawing.Point(198, 115); + this.wmErrorTextBox4.Name = "wmErrorTextBox4"; + this.wmErrorTextBox4.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox4.TabIndex = 1; + this.wmErrorTextBox4.Visible = false; + // + // wmErrorLabel4 + // + this.wmErrorLabel4.AutoSize = true; + this.wmErrorLabel4.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel4.Location = new System.Drawing.Point(33, 121); + this.wmErrorLabel4.Name = "wmErrorLabel4"; + this.wmErrorLabel4.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel4.TabIndex = 0; + this.wmErrorLabel4.Text = "Error [%]"; + this.wmErrorLabel4.Visible = false; + // + // wmErrorTextBox5 + // + this.wmErrorTextBox5.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox5.Location = new System.Drawing.Point(198, 144); + this.wmErrorTextBox5.Name = "wmErrorTextBox5"; + this.wmErrorTextBox5.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox5.TabIndex = 1; + this.wmErrorTextBox5.Visible = false; + // + // wmErrorLabel5 + // + this.wmErrorLabel5.AutoSize = true; + this.wmErrorLabel5.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel5.Location = new System.Drawing.Point(33, 150); + this.wmErrorLabel5.Name = "wmErrorLabel5"; + this.wmErrorLabel5.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel5.TabIndex = 0; + this.wmErrorLabel5.Text = "Error [%]"; + this.wmErrorLabel5.Visible = false; + // + // wmErrorTextBox6 + // + this.wmErrorTextBox6.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox6.Location = new System.Drawing.Point(198, 173); + this.wmErrorTextBox6.Name = "wmErrorTextBox6"; + this.wmErrorTextBox6.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox6.TabIndex = 1; + this.wmErrorTextBox6.Visible = false; + // + // wmErrorLabel6 + // + this.wmErrorLabel6.AutoSize = true; + this.wmErrorLabel6.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel6.Location = new System.Drawing.Point(33, 180); + this.wmErrorLabel6.Name = "wmErrorLabel6"; + this.wmErrorLabel6.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel6.TabIndex = 0; + this.wmErrorLabel6.Text = "Error [%]"; + this.wmErrorLabel6.Visible = false; + // + // wmErrorTextBox1 + // + this.wmErrorTextBox1.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox1.Location = new System.Drawing.Point(198, 28); + this.wmErrorTextBox1.Name = "wmErrorTextBox1"; + this.wmErrorTextBox1.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox1.TabIndex = 1; + this.wmErrorTextBox1.Visible = false; + // + // wmErrorTextBox7 + // + this.wmErrorTextBox7.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox7.Location = new System.Drawing.Point(198, 202); + this.wmErrorTextBox7.Name = "wmErrorTextBox7"; + this.wmErrorTextBox7.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox7.TabIndex = 9; + this.wmErrorTextBox7.Visible = false; + // + // wmErrorLabel7 + // + this.wmErrorLabel7.AutoSize = true; + this.wmErrorLabel7.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel7.Location = new System.Drawing.Point(33, 209); + this.wmErrorLabel7.Name = "wmErrorLabel7"; + this.wmErrorLabel7.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel7.TabIndex = 8; + this.wmErrorLabel7.Text = "Error [%]"; + this.wmErrorLabel7.Visible = false; + // + // wmErrorTextBox8 + // + this.wmErrorTextBox8.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox8.Location = new System.Drawing.Point(198, 231); + this.wmErrorTextBox8.Name = "wmErrorTextBox8"; + this.wmErrorTextBox8.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox8.TabIndex = 11; + this.wmErrorTextBox8.Visible = false; + // + // wmErrorLabel8 + // + this.wmErrorLabel8.AutoSize = true; + this.wmErrorLabel8.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel8.Location = new System.Drawing.Point(33, 238); + this.wmErrorLabel8.Name = "wmErrorLabel8"; + this.wmErrorLabel8.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel8.TabIndex = 10; + this.wmErrorLabel8.Text = "Error [%]"; + this.wmErrorLabel8.Visible = false; + // + // wmErrorTextBox9 + // + this.wmErrorTextBox9.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox9.Location = new System.Drawing.Point(198, 260); + this.wmErrorTextBox9.Name = "wmErrorTextBox9"; + this.wmErrorTextBox9.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox9.TabIndex = 13; + this.wmErrorTextBox9.Visible = false; + // + // wmErrorLabel9 + // + this.wmErrorLabel9.AutoSize = true; + this.wmErrorLabel9.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel9.Location = new System.Drawing.Point(33, 266); + this.wmErrorLabel9.Name = "wmErrorLabel9"; + this.wmErrorLabel9.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel9.TabIndex = 12; + this.wmErrorLabel9.Text = "Error [%]"; + this.wmErrorLabel9.Visible = false; + // + // wmErrorTextBox10 + // + this.wmErrorTextBox10.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox10.Location = new System.Drawing.Point(198, 289); + this.wmErrorTextBox10.Name = "wmErrorTextBox10"; + this.wmErrorTextBox10.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox10.TabIndex = 15; + this.wmErrorTextBox10.Visible = false; + // + // wmErrorLabel10 + // + this.wmErrorLabel10.AutoSize = true; + this.wmErrorLabel10.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel10.Location = new System.Drawing.Point(33, 295); + this.wmErrorLabel10.Name = "wmErrorLabel10"; + this.wmErrorLabel10.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel10.TabIndex = 14; + this.wmErrorLabel10.Text = "Error [%]"; + this.wmErrorLabel10.Visible = false; + // + // wmErrorTextBox12 + // + this.wmErrorTextBox12.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox12.Location = new System.Drawing.Point(198, 347); + this.wmErrorTextBox12.Name = "wmErrorTextBox12"; + this.wmErrorTextBox12.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox12.TabIndex = 19; + this.wmErrorTextBox12.Visible = false; + // + // wmErrorLabel12 + // + this.wmErrorLabel12.AutoSize = true; + this.wmErrorLabel12.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel12.Location = new System.Drawing.Point(33, 353); + this.wmErrorLabel12.Name = "wmErrorLabel12"; + this.wmErrorLabel12.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel12.TabIndex = 18; + this.wmErrorLabel12.Text = "Error [%]"; + this.wmErrorLabel12.Visible = false; + // + // wmErrorTextBox11 + // + this.wmErrorTextBox11.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox11.Location = new System.Drawing.Point(198, 318); + this.wmErrorTextBox11.Name = "wmErrorTextBox11"; + this.wmErrorTextBox11.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox11.TabIndex = 17; + this.wmErrorTextBox11.Visible = false; + // + // wmErrorLabel11 + // + this.wmErrorLabel11.AutoSize = true; + this.wmErrorLabel11.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel11.Location = new System.Drawing.Point(33, 324); + this.wmErrorLabel11.Name = "wmErrorLabel11"; + this.wmErrorLabel11.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel11.TabIndex = 16; + this.wmErrorLabel11.Text = "Error [%]"; + this.wmErrorLabel11.Visible = false; + // + // wmErrorTextBox24 + // + this.wmErrorTextBox24.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox24.Location = new System.Drawing.Point(198, 695); + this.wmErrorTextBox24.Name = "wmErrorTextBox24"; + this.wmErrorTextBox24.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox24.TabIndex = 43; + this.wmErrorTextBox24.Visible = false; + // + // wmErrorLabel24 + // + this.wmErrorLabel24.AutoSize = true; + this.wmErrorLabel24.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel24.Location = new System.Drawing.Point(33, 701); + this.wmErrorLabel24.Name = "wmErrorLabel24"; + this.wmErrorLabel24.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel24.TabIndex = 42; + this.wmErrorLabel24.Text = "Error [%]"; + this.wmErrorLabel24.Visible = false; + // + // wmErrorTextBox23 + // + this.wmErrorTextBox23.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox23.Location = new System.Drawing.Point(198, 666); + this.wmErrorTextBox23.Name = "wmErrorTextBox23"; + this.wmErrorTextBox23.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox23.TabIndex = 41; + this.wmErrorTextBox23.Visible = false; + // + // wmErrorLabel23 + // + this.wmErrorLabel23.AutoSize = true; + this.wmErrorLabel23.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel23.Location = new System.Drawing.Point(33, 672); + this.wmErrorLabel23.Name = "wmErrorLabel23"; + this.wmErrorLabel23.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel23.TabIndex = 40; + this.wmErrorLabel23.Text = "Error [%]"; + this.wmErrorLabel23.Visible = false; + // + // wmErrorTextBox22 + // + this.wmErrorTextBox22.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox22.Location = new System.Drawing.Point(198, 637); + this.wmErrorTextBox22.Name = "wmErrorTextBox22"; + this.wmErrorTextBox22.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox22.TabIndex = 39; + this.wmErrorTextBox22.Visible = false; + // + // wmErrorLabel22 + // + this.wmErrorLabel22.AutoSize = true; + this.wmErrorLabel22.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel22.Location = new System.Drawing.Point(33, 643); + this.wmErrorLabel22.Name = "wmErrorLabel22"; + this.wmErrorLabel22.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel22.TabIndex = 38; + this.wmErrorLabel22.Text = "Error [%]"; + this.wmErrorLabel22.Visible = false; + // + // wmErrorTextBox21 + // + this.wmErrorTextBox21.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox21.Location = new System.Drawing.Point(198, 608); + this.wmErrorTextBox21.Name = "wmErrorTextBox21"; + this.wmErrorTextBox21.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox21.TabIndex = 37; + this.wmErrorTextBox21.Visible = false; + // + // wmErrorLabel21 + // + this.wmErrorLabel21.AutoSize = true; + this.wmErrorLabel21.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel21.Location = new System.Drawing.Point(33, 614); + this.wmErrorLabel21.Name = "wmErrorLabel21"; + this.wmErrorLabel21.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel21.TabIndex = 36; + this.wmErrorLabel21.Text = "Error [%]"; + this.wmErrorLabel21.Visible = false; + // + // wmErrorTextBox20 + // + this.wmErrorTextBox20.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox20.Location = new System.Drawing.Point(198, 579); + this.wmErrorTextBox20.Name = "wmErrorTextBox20"; + this.wmErrorTextBox20.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox20.TabIndex = 35; + this.wmErrorTextBox20.Visible = false; + // + // wmErrorLabel20 + // + this.wmErrorLabel20.AutoSize = true; + this.wmErrorLabel20.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel20.Location = new System.Drawing.Point(33, 586); + this.wmErrorLabel20.Name = "wmErrorLabel20"; + this.wmErrorLabel20.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel20.TabIndex = 34; + this.wmErrorLabel20.Text = "Error [%]"; + this.wmErrorLabel20.Visible = false; + // + // wmErrorTextBox19 + // + this.wmErrorTextBox19.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox19.Location = new System.Drawing.Point(198, 550); + this.wmErrorTextBox19.Name = "wmErrorTextBox19"; + this.wmErrorTextBox19.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox19.TabIndex = 33; + this.wmErrorTextBox19.Visible = false; + // + // wmErrorLabel19 + // + this.wmErrorLabel19.AutoSize = true; + this.wmErrorLabel19.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel19.Location = new System.Drawing.Point(33, 557); + this.wmErrorLabel19.Name = "wmErrorLabel19"; + this.wmErrorLabel19.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel19.TabIndex = 32; + this.wmErrorLabel19.Text = "Error [%]"; + this.wmErrorLabel19.Visible = false; + // + // wmErrorTextBox18 + // + this.wmErrorTextBox18.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox18.Location = new System.Drawing.Point(198, 521); + this.wmErrorTextBox18.Name = "wmErrorTextBox18"; + this.wmErrorTextBox18.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox18.TabIndex = 27; + this.wmErrorTextBox18.Visible = false; + // + // wmErrorLabel18 + // + this.wmErrorLabel18.AutoSize = true; + this.wmErrorLabel18.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel18.Location = new System.Drawing.Point(33, 528); + this.wmErrorLabel18.Name = "wmErrorLabel18"; + this.wmErrorLabel18.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel18.TabIndex = 23; + this.wmErrorLabel18.Text = "Error [%]"; + this.wmErrorLabel18.Visible = false; + // + // wmErrorTextBox17 + // + this.wmErrorTextBox17.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox17.Location = new System.Drawing.Point(198, 492); + this.wmErrorTextBox17.Name = "wmErrorTextBox17"; + this.wmErrorTextBox17.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox17.TabIndex = 26; + this.wmErrorTextBox17.Visible = false; + // + // wmErrorLabel17 + // + this.wmErrorLabel17.AutoSize = true; + this.wmErrorLabel17.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel17.Location = new System.Drawing.Point(33, 498); + this.wmErrorLabel17.Name = "wmErrorLabel17"; + this.wmErrorLabel17.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel17.TabIndex = 22; + this.wmErrorLabel17.Text = "Error [%]"; + this.wmErrorLabel17.Visible = false; + // + // wmErrorTextBox16 + // + this.wmErrorTextBox16.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox16.Location = new System.Drawing.Point(198, 463); + this.wmErrorTextBox16.Name = "wmErrorTextBox16"; + this.wmErrorTextBox16.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox16.TabIndex = 30; + this.wmErrorTextBox16.Visible = false; + // + // wmErrorLabel16 + // + this.wmErrorLabel16.AutoSize = true; + this.wmErrorLabel16.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel16.Location = new System.Drawing.Point(33, 469); + this.wmErrorLabel16.Name = "wmErrorLabel16"; + this.wmErrorLabel16.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel16.TabIndex = 21; + this.wmErrorLabel16.Text = "Error [%]"; + this.wmErrorLabel16.Visible = false; + // + // wmErrorTextBox15 + // + this.wmErrorTextBox15.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox15.Location = new System.Drawing.Point(198, 434); + this.wmErrorTextBox15.Name = "wmErrorTextBox15"; + this.wmErrorTextBox15.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox15.TabIndex = 31; + this.wmErrorTextBox15.Visible = false; + // + // wmErrorLabel15 + // + this.wmErrorLabel15.AutoSize = true; + this.wmErrorLabel15.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel15.Location = new System.Drawing.Point(33, 440); + this.wmErrorLabel15.Name = "wmErrorLabel15"; + this.wmErrorLabel15.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel15.TabIndex = 20; + this.wmErrorLabel15.Text = "Error [%]"; + this.wmErrorLabel15.Visible = false; + // + // wmErrorTextBox14 + // + this.wmErrorTextBox14.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox14.Location = new System.Drawing.Point(198, 405); + this.wmErrorTextBox14.Name = "wmErrorTextBox14"; + this.wmErrorTextBox14.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox14.TabIndex = 28; + this.wmErrorTextBox14.Visible = false; + // + // wmErrorLabel14 + // + this.wmErrorLabel14.AutoSize = true; + this.wmErrorLabel14.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel14.Location = new System.Drawing.Point(33, 411); + this.wmErrorLabel14.Name = "wmErrorLabel14"; + this.wmErrorLabel14.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel14.TabIndex = 25; + this.wmErrorLabel14.Text = "Error [%]"; + this.wmErrorLabel14.Visible = false; + // + // wmErrorTextBox13 + // + this.wmErrorTextBox13.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox13.Location = new System.Drawing.Point(198, 376); + this.wmErrorTextBox13.Name = "wmErrorTextBox13"; + this.wmErrorTextBox13.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox13.TabIndex = 29; + this.wmErrorTextBox13.Visible = false; + // + // wmErrorLabel13 + // + this.wmErrorLabel13.AutoSize = true; + this.wmErrorLabel13.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel13.Location = new System.Drawing.Point(33, 382); + this.wmErrorLabel13.Name = "wmErrorLabel13"; + this.wmErrorLabel13.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel13.TabIndex = 24; + this.wmErrorLabel13.Text = "Error [%]"; + this.wmErrorLabel13.Visible = false; + // + // toTestMdBtn + // + this.toTestMdBtn.Font = new System.Drawing.Font("Verdana", 14.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.toTestMdBtn.ForeColor = System.Drawing.Color.Black; + this.toTestMdBtn.Location = new System.Drawing.Point(1157, 254); + this.toTestMdBtn.Name = "toTestMdBtn"; + this.toTestMdBtn.Size = new System.Drawing.Size(98, 63); + this.toTestMdBtn.TabIndex = 44; + this.toTestMdBtn.Text = "to Test Mode"; + this.toTestMdBtn.UseVisualStyleBackColor = true; + this.toTestMdBtn.Click += new System.EventHandler(this.toTestMdBtn_Click); + // + // toActiveMdBtn + // + this.toActiveMdBtn.Font = new System.Drawing.Font("Verdana", 14.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.toActiveMdBtn.ForeColor = System.Drawing.Color.Black; + this.toActiveMdBtn.Location = new System.Drawing.Point(1157, 324); + this.toActiveMdBtn.Name = "toActiveMdBtn"; + this.toActiveMdBtn.Size = new System.Drawing.Size(98, 63); + this.toActiveMdBtn.TabIndex = 45; + this.toActiveMdBtn.Text = "to Act. Mode"; + this.toActiveMdBtn.UseVisualStyleBackColor = true; + this.toActiveMdBtn.Click += new System.EventHandler(this.toActiveMdBtn_Click); + // + // readConfigBtn + // + this.readConfigBtn.Font = new System.Drawing.Font("Verdana", 14.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.readConfigBtn.ForeColor = System.Drawing.Color.Black; + this.readConfigBtn.Location = new System.Drawing.Point(1157, 185); + this.readConfigBtn.Name = "readConfigBtn"; + this.readConfigBtn.Size = new System.Drawing.Size(98, 63); + this.readConfigBtn.TabIndex = 46; + this.readConfigBtn.Text = "Read Config."; + this.readConfigBtn.UseVisualStyleBackColor = true; + this.readConfigBtn.Click += new System.EventHandler(this.readConfigBtn_Click); + // + // wmErrorTextBox48 + // + this.wmErrorTextBox48.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox48.Location = new System.Drawing.Point(759, 695); + this.wmErrorTextBox48.Name = "wmErrorTextBox48"; + this.wmErrorTextBox48.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox48.TabIndex = 94; + this.wmErrorTextBox48.Visible = false; + // + // wmErrorLabel48 + // + this.wmErrorLabel48.AutoSize = true; + this.wmErrorLabel48.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel48.Location = new System.Drawing.Point(594, 701); + this.wmErrorLabel48.Name = "wmErrorLabel48"; + this.wmErrorLabel48.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel48.TabIndex = 93; + this.wmErrorLabel48.Text = "Error [%]"; + this.wmErrorLabel48.Visible = false; + // + // wmErrorTextBox47 + // + this.wmErrorTextBox47.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox47.Location = new System.Drawing.Point(759, 666); + this.wmErrorTextBox47.Name = "wmErrorTextBox47"; + this.wmErrorTextBox47.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox47.TabIndex = 92; + this.wmErrorTextBox47.Visible = false; + // + // wmErrorLabel47 + // + this.wmErrorLabel47.AutoSize = true; + this.wmErrorLabel47.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel47.Location = new System.Drawing.Point(594, 672); + this.wmErrorLabel47.Name = "wmErrorLabel47"; + this.wmErrorLabel47.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel47.TabIndex = 91; + this.wmErrorLabel47.Text = "Error [%]"; + this.wmErrorLabel47.Visible = false; + // + // wmErrorTextBox46 + // + this.wmErrorTextBox46.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox46.Location = new System.Drawing.Point(759, 637); + this.wmErrorTextBox46.Name = "wmErrorTextBox46"; + this.wmErrorTextBox46.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox46.TabIndex = 90; + this.wmErrorTextBox46.Visible = false; + // + // wmErrorLabel46 + // + this.wmErrorLabel46.AutoSize = true; + this.wmErrorLabel46.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel46.Location = new System.Drawing.Point(594, 643); + this.wmErrorLabel46.Name = "wmErrorLabel46"; + this.wmErrorLabel46.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel46.TabIndex = 89; + this.wmErrorLabel46.Text = "Error [%]"; + this.wmErrorLabel46.Visible = false; + // + // wmErrorTextBox45 + // + this.wmErrorTextBox45.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox45.Location = new System.Drawing.Point(759, 608); + this.wmErrorTextBox45.Name = "wmErrorTextBox45"; + this.wmErrorTextBox45.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox45.TabIndex = 88; + this.wmErrorTextBox45.Visible = false; + // + // wmErrorLabel45 + // + this.wmErrorLabel45.AutoSize = true; + this.wmErrorLabel45.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel45.Location = new System.Drawing.Point(594, 614); + this.wmErrorLabel45.Name = "wmErrorLabel45"; + this.wmErrorLabel45.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel45.TabIndex = 87; + this.wmErrorLabel45.Text = "Error [%]"; + this.wmErrorLabel45.Visible = false; + // + // wmErrorTextBox44 + // + this.wmErrorTextBox44.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox44.Location = new System.Drawing.Point(759, 579); + this.wmErrorTextBox44.Name = "wmErrorTextBox44"; + this.wmErrorTextBox44.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox44.TabIndex = 86; + this.wmErrorTextBox44.Visible = false; + // + // wmErrorLabel44 + // + this.wmErrorLabel44.AutoSize = true; + this.wmErrorLabel44.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel44.Location = new System.Drawing.Point(594, 586); + this.wmErrorLabel44.Name = "wmErrorLabel44"; + this.wmErrorLabel44.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel44.TabIndex = 85; + this.wmErrorLabel44.Text = "Error [%]"; + this.wmErrorLabel44.Visible = false; + // + // wmErrorTextBox43 + // + this.wmErrorTextBox43.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox43.Location = new System.Drawing.Point(759, 550); + this.wmErrorTextBox43.Name = "wmErrorTextBox43"; + this.wmErrorTextBox43.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox43.TabIndex = 84; + this.wmErrorTextBox43.Visible = false; + // + // wmErrorLabel43 + // + this.wmErrorLabel43.AutoSize = true; + this.wmErrorLabel43.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel43.Location = new System.Drawing.Point(594, 557); + this.wmErrorLabel43.Name = "wmErrorLabel43"; + this.wmErrorLabel43.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel43.TabIndex = 83; + this.wmErrorLabel43.Text = "Error [%]"; + this.wmErrorLabel43.Visible = false; + // + // wmErrorTextBox42 + // + this.wmErrorTextBox42.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox42.Location = new System.Drawing.Point(759, 521); + this.wmErrorTextBox42.Name = "wmErrorTextBox42"; + this.wmErrorTextBox42.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox42.TabIndex = 78; + this.wmErrorTextBox42.Visible = false; + // + // wmErrorLabel42 + // + this.wmErrorLabel42.AutoSize = true; + this.wmErrorLabel42.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel42.Location = new System.Drawing.Point(594, 528); + this.wmErrorLabel42.Name = "wmErrorLabel42"; + this.wmErrorLabel42.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel42.TabIndex = 74; + this.wmErrorLabel42.Text = "Error [%]"; + this.wmErrorLabel42.Visible = false; + // + // wmErrorTextBox41 + // + this.wmErrorTextBox41.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox41.Location = new System.Drawing.Point(759, 492); + this.wmErrorTextBox41.Name = "wmErrorTextBox41"; + this.wmErrorTextBox41.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox41.TabIndex = 77; + this.wmErrorTextBox41.Visible = false; + // + // wmErrorLabel41 + // + this.wmErrorLabel41.AutoSize = true; + this.wmErrorLabel41.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel41.Location = new System.Drawing.Point(594, 498); + this.wmErrorLabel41.Name = "wmErrorLabel41"; + this.wmErrorLabel41.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel41.TabIndex = 73; + this.wmErrorLabel41.Text = "Error [%]"; + this.wmErrorLabel41.Visible = false; + // + // wmErrorTextBox40 + // + this.wmErrorTextBox40.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox40.Location = new System.Drawing.Point(759, 463); + this.wmErrorTextBox40.Name = "wmErrorTextBox40"; + this.wmErrorTextBox40.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox40.TabIndex = 81; + this.wmErrorTextBox40.Visible = false; + // + // wmErrorLabel40 + // + this.wmErrorLabel40.AutoSize = true; + this.wmErrorLabel40.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel40.Location = new System.Drawing.Point(594, 469); + this.wmErrorLabel40.Name = "wmErrorLabel40"; + this.wmErrorLabel40.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel40.TabIndex = 72; + this.wmErrorLabel40.Text = "Error [%]"; + this.wmErrorLabel40.Visible = false; + // + // wmErrorTextBox39 + // + this.wmErrorTextBox39.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox39.Location = new System.Drawing.Point(759, 434); + this.wmErrorTextBox39.Name = "wmErrorTextBox39"; + this.wmErrorTextBox39.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox39.TabIndex = 82; + this.wmErrorTextBox39.Visible = false; + // + // wmErrorLabel39 + // + this.wmErrorLabel39.AutoSize = true; + this.wmErrorLabel39.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel39.Location = new System.Drawing.Point(594, 440); + this.wmErrorLabel39.Name = "wmErrorLabel39"; + this.wmErrorLabel39.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel39.TabIndex = 71; + this.wmErrorLabel39.Text = "Error [%]"; + this.wmErrorLabel39.Visible = false; + // + // wmErrorTextBox38 + // + this.wmErrorTextBox38.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox38.Location = new System.Drawing.Point(759, 405); + this.wmErrorTextBox38.Name = "wmErrorTextBox38"; + this.wmErrorTextBox38.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox38.TabIndex = 79; + this.wmErrorTextBox38.Visible = false; + // + // wmErrorLabel38 + // + this.wmErrorLabel38.AutoSize = true; + this.wmErrorLabel38.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel38.Location = new System.Drawing.Point(594, 411); + this.wmErrorLabel38.Name = "wmErrorLabel38"; + this.wmErrorLabel38.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel38.TabIndex = 76; + this.wmErrorLabel38.Text = "Error [%]"; + this.wmErrorLabel38.Visible = false; + // + // wmErrorTextBox37 + // + this.wmErrorTextBox37.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox37.Location = new System.Drawing.Point(759, 376); + this.wmErrorTextBox37.Name = "wmErrorTextBox37"; + this.wmErrorTextBox37.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox37.TabIndex = 80; + this.wmErrorTextBox37.Visible = false; + // + // wmErrorLabel37 + // + this.wmErrorLabel37.AutoSize = true; + this.wmErrorLabel37.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel37.Location = new System.Drawing.Point(594, 382); + this.wmErrorLabel37.Name = "wmErrorLabel37"; + this.wmErrorLabel37.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel37.TabIndex = 75; + this.wmErrorLabel37.Text = "Error [%]"; + this.wmErrorLabel37.Visible = false; + // + // wmErrorTextBox36 + // + this.wmErrorTextBox36.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox36.Location = new System.Drawing.Point(759, 347); + this.wmErrorTextBox36.Name = "wmErrorTextBox36"; + this.wmErrorTextBox36.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox36.TabIndex = 70; + this.wmErrorTextBox36.Visible = false; + // + // wmErrorLabel36 + // + this.wmErrorLabel36.AutoSize = true; + this.wmErrorLabel36.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel36.Location = new System.Drawing.Point(594, 353); + this.wmErrorLabel36.Name = "wmErrorLabel36"; + this.wmErrorLabel36.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel36.TabIndex = 69; + this.wmErrorLabel36.Text = "Error [%]"; + this.wmErrorLabel36.Visible = false; + // + // wmErrorTextBox35 + // + this.wmErrorTextBox35.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox35.Location = new System.Drawing.Point(759, 318); + this.wmErrorTextBox35.Name = "wmErrorTextBox35"; + this.wmErrorTextBox35.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox35.TabIndex = 68; + this.wmErrorTextBox35.Visible = false; + // + // wmErrorLabel35 + // + this.wmErrorLabel35.AutoSize = true; + this.wmErrorLabel35.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel35.Location = new System.Drawing.Point(594, 324); + this.wmErrorLabel35.Name = "wmErrorLabel35"; + this.wmErrorLabel35.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel35.TabIndex = 67; + this.wmErrorLabel35.Text = "Error [%]"; + this.wmErrorLabel35.Visible = false; + // + // wmErrorTextBox34 + // + this.wmErrorTextBox34.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox34.Location = new System.Drawing.Point(759, 289); + this.wmErrorTextBox34.Name = "wmErrorTextBox34"; + this.wmErrorTextBox34.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox34.TabIndex = 66; + this.wmErrorTextBox34.Visible = false; + // + // wmErrorLabel34 + // + this.wmErrorLabel34.AutoSize = true; + this.wmErrorLabel34.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel34.Location = new System.Drawing.Point(594, 295); + this.wmErrorLabel34.Name = "wmErrorLabel34"; + this.wmErrorLabel34.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel34.TabIndex = 65; + this.wmErrorLabel34.Text = "Error [%]"; + this.wmErrorLabel34.Visible = false; + // + // wmErrorTextBox33 + // + this.wmErrorTextBox33.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox33.Location = new System.Drawing.Point(759, 260); + this.wmErrorTextBox33.Name = "wmErrorTextBox33"; + this.wmErrorTextBox33.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox33.TabIndex = 64; + this.wmErrorTextBox33.Visible = false; + // + // wmErrorLabel33 + // + this.wmErrorLabel33.AutoSize = true; + this.wmErrorLabel33.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel33.Location = new System.Drawing.Point(594, 266); + this.wmErrorLabel33.Name = "wmErrorLabel33"; + this.wmErrorLabel33.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel33.TabIndex = 63; + this.wmErrorLabel33.Text = "Error [%]"; + this.wmErrorLabel33.Visible = false; + // + // wmErrorTextBox32 + // + this.wmErrorTextBox32.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox32.Location = new System.Drawing.Point(759, 231); + this.wmErrorTextBox32.Name = "wmErrorTextBox32"; + this.wmErrorTextBox32.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox32.TabIndex = 62; + this.wmErrorTextBox32.Visible = false; + // + // wmErrorLabel32 + // + this.wmErrorLabel32.AutoSize = true; + this.wmErrorLabel32.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel32.Location = new System.Drawing.Point(594, 238); + this.wmErrorLabel32.Name = "wmErrorLabel32"; + this.wmErrorLabel32.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel32.TabIndex = 61; + this.wmErrorLabel32.Text = "Error [%]"; + this.wmErrorLabel32.Visible = false; + // + // wmErrorTextBox31 + // + this.wmErrorTextBox31.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox31.Location = new System.Drawing.Point(759, 202); + this.wmErrorTextBox31.Name = "wmErrorTextBox31"; + this.wmErrorTextBox31.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox31.TabIndex = 60; + this.wmErrorTextBox31.Visible = false; + // + // wmErrorLabel31 + // + this.wmErrorLabel31.AutoSize = true; + this.wmErrorLabel31.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel31.Location = new System.Drawing.Point(594, 209); + this.wmErrorLabel31.Name = "wmErrorLabel31"; + this.wmErrorLabel31.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel31.TabIndex = 59; + this.wmErrorLabel31.Text = "Error [%]"; + this.wmErrorLabel31.Visible = false; + // + // wmErrorTextBox30 + // + this.wmErrorTextBox30.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox30.Location = new System.Drawing.Point(759, 173); + this.wmErrorTextBox30.Name = "wmErrorTextBox30"; + this.wmErrorTextBox30.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox30.TabIndex = 54; + this.wmErrorTextBox30.Visible = false; + // + // wmErrorLabel30 + // + this.wmErrorLabel30.AutoSize = true; + this.wmErrorLabel30.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel30.Location = new System.Drawing.Point(594, 180); + this.wmErrorLabel30.Name = "wmErrorLabel30"; + this.wmErrorLabel30.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel30.TabIndex = 50; + this.wmErrorLabel30.Text = "Error [%]"; + this.wmErrorLabel30.Visible = false; + // + // wmErrorTextBox29 + // + this.wmErrorTextBox29.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox29.Location = new System.Drawing.Point(759, 144); + this.wmErrorTextBox29.Name = "wmErrorTextBox29"; + this.wmErrorTextBox29.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox29.TabIndex = 53; + this.wmErrorTextBox29.Visible = false; + // + // wmErrorLabel29 + // + this.wmErrorLabel29.AutoSize = true; + this.wmErrorLabel29.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel29.Location = new System.Drawing.Point(594, 150); + this.wmErrorLabel29.Name = "wmErrorLabel29"; + this.wmErrorLabel29.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel29.TabIndex = 49; + this.wmErrorLabel29.Text = "Error [%]"; + this.wmErrorLabel29.Visible = false; + // + // wmErrorTextBox28 + // + this.wmErrorTextBox28.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox28.Location = new System.Drawing.Point(759, 115); + this.wmErrorTextBox28.Name = "wmErrorTextBox28"; + this.wmErrorTextBox28.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox28.TabIndex = 57; + this.wmErrorTextBox28.Visible = false; + // + // wmErrorLabel28 + // + this.wmErrorLabel28.AutoSize = true; + this.wmErrorLabel28.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel28.Location = new System.Drawing.Point(594, 121); + this.wmErrorLabel28.Name = "wmErrorLabel28"; + this.wmErrorLabel28.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel28.TabIndex = 48; + this.wmErrorLabel28.Text = "Error [%]"; + this.wmErrorLabel28.Visible = false; + // + // wmErrorTextBox27 + // + this.wmErrorTextBox27.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox27.Location = new System.Drawing.Point(759, 86); + this.wmErrorTextBox27.Name = "wmErrorTextBox27"; + this.wmErrorTextBox27.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox27.TabIndex = 58; + this.wmErrorTextBox27.Visible = false; + // + // wmErrorLabel27 + // + this.wmErrorLabel27.AutoSize = true; + this.wmErrorLabel27.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel27.Location = new System.Drawing.Point(594, 92); + this.wmErrorLabel27.Name = "wmErrorLabel27"; + this.wmErrorLabel27.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel27.TabIndex = 47; + this.wmErrorLabel27.Text = "Error [%]"; + this.wmErrorLabel27.Visible = false; + // + // wmErrorTextBox26 + // + this.wmErrorTextBox26.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox26.Location = new System.Drawing.Point(759, 57); + this.wmErrorTextBox26.Name = "wmErrorTextBox26"; + this.wmErrorTextBox26.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox26.TabIndex = 55; + this.wmErrorTextBox26.Visible = false; + // + // wmErrorLabel26 + // + this.wmErrorLabel26.AutoSize = true; + this.wmErrorLabel26.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel26.Location = new System.Drawing.Point(594, 63); + this.wmErrorLabel26.Name = "wmErrorLabel26"; + this.wmErrorLabel26.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel26.TabIndex = 52; + this.wmErrorLabel26.Text = "Error [%]"; + this.wmErrorLabel26.Visible = false; + // + // wmErrorTextBox25 + // + this.wmErrorTextBox25.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorTextBox25.Location = new System.Drawing.Point(759, 28); + this.wmErrorTextBox25.Name = "wmErrorTextBox25"; + this.wmErrorTextBox25.Size = new System.Drawing.Size(380, 23); + this.wmErrorTextBox25.TabIndex = 56; + this.wmErrorTextBox25.Visible = false; + // + // wmErrorLabel25 + // + this.wmErrorLabel25.AutoSize = true; + this.wmErrorLabel25.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmErrorLabel25.Location = new System.Drawing.Point(594, 34); + this.wmErrorLabel25.Name = "wmErrorLabel25"; + this.wmErrorLabel25.Size = new System.Drawing.Size(69, 16); + this.wmErrorLabel25.TabIndex = 51; + this.wmErrorLabel25.Text = "Error [%]"; + this.wmErrorLabel25.Visible = false; + // + // iPerlCommunicationForm + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.Color.DarkGoldenrod; + this.ClientSize = new System.Drawing.Size(1267, 744); + this.Controls.Add(this.wmErrorTextBox48); + this.Controls.Add(this.wmErrorLabel48); + this.Controls.Add(this.wmErrorTextBox47); + this.Controls.Add(this.wmErrorLabel47); + this.Controls.Add(this.wmErrorTextBox46); + this.Controls.Add(this.wmErrorLabel46); + this.Controls.Add(this.wmErrorTextBox45); + this.Controls.Add(this.wmErrorLabel45); + this.Controls.Add(this.wmErrorTextBox44); + this.Controls.Add(this.wmErrorLabel44); + this.Controls.Add(this.wmErrorTextBox43); + this.Controls.Add(this.wmErrorLabel43); + this.Controls.Add(this.wmErrorTextBox42); + this.Controls.Add(this.wmErrorLabel42); + this.Controls.Add(this.wmErrorTextBox41); + this.Controls.Add(this.wmErrorLabel41); + this.Controls.Add(this.wmErrorTextBox40); + this.Controls.Add(this.wmErrorLabel40); + this.Controls.Add(this.wmErrorTextBox39); + this.Controls.Add(this.wmErrorLabel39); + this.Controls.Add(this.wmErrorTextBox38); + this.Controls.Add(this.wmErrorLabel38); + this.Controls.Add(this.wmErrorTextBox37); + this.Controls.Add(this.wmErrorLabel37); + this.Controls.Add(this.wmErrorTextBox36); + this.Controls.Add(this.wmErrorLabel36); + this.Controls.Add(this.wmErrorTextBox35); + this.Controls.Add(this.wmErrorLabel35); + this.Controls.Add(this.wmErrorTextBox34); + this.Controls.Add(this.wmErrorLabel34); + this.Controls.Add(this.wmErrorTextBox33); + this.Controls.Add(this.wmErrorLabel33); + this.Controls.Add(this.wmErrorTextBox32); + this.Controls.Add(this.wmErrorLabel32); + this.Controls.Add(this.wmErrorTextBox31); + this.Controls.Add(this.wmErrorLabel31); + this.Controls.Add(this.wmErrorTextBox30); + this.Controls.Add(this.wmErrorLabel30); + this.Controls.Add(this.wmErrorTextBox29); + this.Controls.Add(this.wmErrorLabel29); + this.Controls.Add(this.wmErrorTextBox28); + this.Controls.Add(this.wmErrorLabel28); + this.Controls.Add(this.wmErrorTextBox27); + this.Controls.Add(this.wmErrorLabel27); + this.Controls.Add(this.wmErrorTextBox26); + this.Controls.Add(this.wmErrorLabel26); + this.Controls.Add(this.wmErrorTextBox25); + this.Controls.Add(this.wmErrorLabel25); + this.Controls.Add(this.readConfigBtn); + this.Controls.Add(this.toActiveMdBtn); + this.Controls.Add(this.toTestMdBtn); + this.Controls.Add(this.wmErrorTextBox24); + this.Controls.Add(this.wmErrorLabel24); + this.Controls.Add(this.wmErrorTextBox23); + this.Controls.Add(this.wmErrorLabel23); + this.Controls.Add(this.wmErrorTextBox22); + this.Controls.Add(this.wmErrorLabel22); + this.Controls.Add(this.wmErrorTextBox21); + this.Controls.Add(this.wmErrorLabel21); + this.Controls.Add(this.wmErrorTextBox20); + this.Controls.Add(this.wmErrorLabel20); + this.Controls.Add(this.wmErrorTextBox19); + this.Controls.Add(this.wmErrorLabel19); + this.Controls.Add(this.wmErrorTextBox18); + this.Controls.Add(this.wmErrorLabel18); + this.Controls.Add(this.wmErrorTextBox17); + this.Controls.Add(this.wmErrorLabel17); + this.Controls.Add(this.wmErrorTextBox16); + this.Controls.Add(this.wmErrorLabel16); + this.Controls.Add(this.wmErrorTextBox15); + this.Controls.Add(this.wmErrorLabel15); + this.Controls.Add(this.wmErrorTextBox14); + this.Controls.Add(this.wmErrorLabel14); + this.Controls.Add(this.wmErrorTextBox13); + this.Controls.Add(this.wmErrorLabel13); + this.Controls.Add(this.wmErrorTextBox12); + this.Controls.Add(this.wmErrorLabel12); + this.Controls.Add(this.wmErrorTextBox11); + this.Controls.Add(this.wmErrorLabel11); + this.Controls.Add(this.wmErrorTextBox10); + this.Controls.Add(this.wmErrorLabel10); + this.Controls.Add(this.wmErrorTextBox9); + this.Controls.Add(this.wmErrorLabel9); + this.Controls.Add(this.wmErrorTextBox8); + this.Controls.Add(this.wmErrorLabel8); + this.Controls.Add(this.wmErrorTextBox7); + this.Controls.Add(this.wmErrorLabel7); + this.Controls.Add(this.wmErrorTextBox6); + this.Controls.Add(this.wmErrorLabel6); + this.Controls.Add(this.wmErrorTextBox5); + this.Controls.Add(this.wmErrorLabel5); + this.Controls.Add(this.wmErrorTextBox4); + this.Controls.Add(this.wmErrorLabel4); + this.Controls.Add(this.wmErrorTextBox3); + this.Controls.Add(this.wmErrorLabel3); + this.Controls.Add(this.wmErrorTextBox2); + this.Controls.Add(this.wmErrorLabel2); + this.Controls.Add(this.wmErrorTextBox1); + this.Controls.Add(this.wmErrorLabel1); + this.Controls.Add(this.okButton); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow; + this.Name = "iPerlCommunicationForm"; + this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide; + this.Text = "Water Meter States"; + this.TopMost = true; + this.Load += new System.EventHandler(this.WMErrorsForm24_Load); + this.Paint += new System.Windows.Forms.PaintEventHandler(this.WMErrorsForm_Paint); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.TextBox wmErrorTextBox2; + private System.Windows.Forms.Label wmErrorLabel2; + private System.Windows.Forms.Label wmErrorLabel1; + private System.Windows.Forms.Button okButton; + private System.Windows.Forms.TextBox wmErrorTextBox3; + private System.Windows.Forms.Label wmErrorLabel3; + private System.Windows.Forms.TextBox wmErrorTextBox4; + private System.Windows.Forms.Label wmErrorLabel4; + private System.Windows.Forms.TextBox wmErrorTextBox5; + private System.Windows.Forms.Label wmErrorLabel5; + private System.Windows.Forms.TextBox wmErrorTextBox6; + private System.Windows.Forms.Label wmErrorLabel6; + private System.Windows.Forms.TextBox wmErrorTextBox1; + private System.Windows.Forms.TextBox wmErrorTextBox7; + private System.Windows.Forms.Label wmErrorLabel7; + private System.Windows.Forms.TextBox wmErrorTextBox8; + private System.Windows.Forms.Label wmErrorLabel8; + private System.Windows.Forms.TextBox wmErrorTextBox9; + private System.Windows.Forms.Label wmErrorLabel9; + private System.Windows.Forms.TextBox wmErrorTextBox10; + private System.Windows.Forms.Label wmErrorLabel10; + private System.Windows.Forms.TextBox wmErrorTextBox12; + private System.Windows.Forms.Label wmErrorLabel12; + private System.Windows.Forms.TextBox wmErrorTextBox11; + private System.Windows.Forms.Label wmErrorLabel11; + private System.Windows.Forms.TextBox wmErrorTextBox24; + private System.Windows.Forms.Label wmErrorLabel24; + private System.Windows.Forms.TextBox wmErrorTextBox23; + private System.Windows.Forms.Label wmErrorLabel23; + private System.Windows.Forms.TextBox wmErrorTextBox22; + private System.Windows.Forms.Label wmErrorLabel22; + private System.Windows.Forms.TextBox wmErrorTextBox21; + private System.Windows.Forms.Label wmErrorLabel21; + private System.Windows.Forms.TextBox wmErrorTextBox20; + private System.Windows.Forms.Label wmErrorLabel20; + private System.Windows.Forms.TextBox wmErrorTextBox19; + private System.Windows.Forms.Label wmErrorLabel19; + private System.Windows.Forms.TextBox wmErrorTextBox18; + private System.Windows.Forms.Label wmErrorLabel18; + private System.Windows.Forms.TextBox wmErrorTextBox17; + private System.Windows.Forms.Label wmErrorLabel17; + private System.Windows.Forms.TextBox wmErrorTextBox16; + private System.Windows.Forms.Label wmErrorLabel16; + private System.Windows.Forms.TextBox wmErrorTextBox15; + private System.Windows.Forms.Label wmErrorLabel15; + private System.Windows.Forms.TextBox wmErrorTextBox14; + private System.Windows.Forms.Label wmErrorLabel14; + private System.Windows.Forms.TextBox wmErrorTextBox13; + private System.Windows.Forms.Label wmErrorLabel13; + private System.Windows.Forms.Button toTestMdBtn; + private System.Windows.Forms.Button toActiveMdBtn; + private System.Windows.Forms.Button readConfigBtn; + private System.Windows.Forms.TextBox wmErrorTextBox48; + private System.Windows.Forms.Label wmErrorLabel48; + private System.Windows.Forms.TextBox wmErrorTextBox47; + private System.Windows.Forms.Label wmErrorLabel47; + private System.Windows.Forms.TextBox wmErrorTextBox46; + private System.Windows.Forms.Label wmErrorLabel46; + private System.Windows.Forms.TextBox wmErrorTextBox45; + private System.Windows.Forms.Label wmErrorLabel45; + private System.Windows.Forms.TextBox wmErrorTextBox44; + private System.Windows.Forms.Label wmErrorLabel44; + private System.Windows.Forms.TextBox wmErrorTextBox43; + private System.Windows.Forms.Label wmErrorLabel43; + private System.Windows.Forms.TextBox wmErrorTextBox42; + private System.Windows.Forms.Label wmErrorLabel42; + private System.Windows.Forms.TextBox wmErrorTextBox41; + private System.Windows.Forms.Label wmErrorLabel41; + private System.Windows.Forms.TextBox wmErrorTextBox40; + private System.Windows.Forms.Label wmErrorLabel40; + private System.Windows.Forms.TextBox wmErrorTextBox39; + private System.Windows.Forms.Label wmErrorLabel39; + private System.Windows.Forms.TextBox wmErrorTextBox38; + private System.Windows.Forms.Label wmErrorLabel38; + private System.Windows.Forms.TextBox wmErrorTextBox37; + private System.Windows.Forms.Label wmErrorLabel37; + private System.Windows.Forms.TextBox wmErrorTextBox36; + private System.Windows.Forms.Label wmErrorLabel36; + private System.Windows.Forms.TextBox wmErrorTextBox35; + private System.Windows.Forms.Label wmErrorLabel35; + private System.Windows.Forms.TextBox wmErrorTextBox34; + private System.Windows.Forms.Label wmErrorLabel34; + private System.Windows.Forms.TextBox wmErrorTextBox33; + private System.Windows.Forms.Label wmErrorLabel33; + private System.Windows.Forms.TextBox wmErrorTextBox32; + private System.Windows.Forms.Label wmErrorLabel32; + private System.Windows.Forms.TextBox wmErrorTextBox31; + private System.Windows.Forms.Label wmErrorLabel31; + private System.Windows.Forms.TextBox wmErrorTextBox30; + private System.Windows.Forms.Label wmErrorLabel30; + private System.Windows.Forms.TextBox wmErrorTextBox29; + private System.Windows.Forms.Label wmErrorLabel29; + private System.Windows.Forms.TextBox wmErrorTextBox28; + private System.Windows.Forms.Label wmErrorLabel28; + private System.Windows.Forms.TextBox wmErrorTextBox27; + private System.Windows.Forms.Label wmErrorLabel27; + private System.Windows.Forms.TextBox wmErrorTextBox26; + private System.Windows.Forms.Label wmErrorLabel26; + private System.Windows.Forms.TextBox wmErrorTextBox25; + private System.Windows.Forms.Label wmErrorLabel25; + + } +} \ No newline at end of file diff --git a/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/iPerlCommunicationForm.resx b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/iPerlCommunicationForm.resx new file mode 100644 index 000000000..1af7de150 --- /dev/null +++ b/TestBenchFramework/BenchControl/TestMethods/iPerlAdjustment/iPerlCommunicationForm.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/TestBenchFramework/BenchControl/WaterMeter/ProcParams.cs b/TestBenchFramework/BenchControl/WaterMeters/WaterMeter/ProcParams.cs similarity index 98% rename from TestBenchFramework/BenchControl/WaterMeter/ProcParams.cs rename to TestBenchFramework/BenchControl/WaterMeters/WaterMeter/ProcParams.cs index e5697037c..c5e272fb0 100644 --- a/TestBenchFramework/BenchControl/WaterMeter/ProcParams.cs +++ b/TestBenchFramework/BenchControl/WaterMeters/WaterMeter/ProcParams.cs @@ -8,7 +8,7 @@ using System.Xml.Serialization; using TBF.BenchControl.Generic; using TBF.Resources; -namespace TBF.BenchControl.WaterMeter +namespace TBF.BenchControl.WaterMeters.WaterMeter { public class ProcParams : ProcedureParamsBase, IParamsProvider, IProcedureParams { diff --git a/TestBenchFramework/BenchControl/WaterMeter/WaterMeter.cs b/TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeter.cs similarity index 97% rename from TestBenchFramework/BenchControl/WaterMeter/WaterMeter.cs rename to TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeter.cs index 5e1ad2c41..7bed008d1 100644 --- a/TestBenchFramework/BenchControl/WaterMeter/WaterMeter.cs +++ b/TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeter.cs @@ -6,7 +6,7 @@ using System.Collections.Generic; using log4net; using TBF.BenchControl; -namespace TBF.BenchControl.WaterMeter +namespace TBF.BenchControl.WaterMeters.WaterMeter { /// /// This component = instance of this class is a placeholder for a combined main watermeter diff --git a/TestBenchFramework/BenchControl/WaterMeter/WaterMeterCfg.cs b/TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeterCfg.cs similarity index 96% rename from TestBenchFramework/BenchControl/WaterMeter/WaterMeterCfg.cs rename to TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeterCfg.cs index a179903e4..9b6db59c0 100644 --- a/TestBenchFramework/BenchControl/WaterMeter/WaterMeterCfg.cs +++ b/TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeterCfg.cs @@ -8,7 +8,7 @@ using System.Xml.Serialization; using TBF.BenchControl.Generic; using TBF.Resources; -namespace TBF.BenchControl.WaterMeter +namespace TBF.BenchControl.WaterMeters.WaterMeter { public class WaterMeterCfg : ComponentCfgBase, Generic.IComponentCfg { diff --git a/TestBenchFramework/BenchControl/WaterMeter/WaterMeterCfgCtrl.cs b/TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeterCfgCtrl.cs similarity index 92% rename from TestBenchFramework/BenchControl/WaterMeter/WaterMeterCfgCtrl.cs rename to TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeterCfgCtrl.cs index 1023f7433..c1bcb98b2 100644 --- a/TestBenchFramework/BenchControl/WaterMeter/WaterMeterCfgCtrl.cs +++ b/TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeterCfgCtrl.cs @@ -7,7 +7,7 @@ using log4net; using TBF.BenchControl.Generic; using TBF.Resources; -namespace TBF.BenchControl.WaterMeter +namespace TBF.BenchControl.WaterMeters.WaterMeter { public partial class WaterMeterCfgCtrl : UserControl, IComponentCfgCtrl { @@ -31,7 +31,7 @@ namespace TBF.BenchControl.WaterMeter InitializeComponent(); } - private void EntryFormCfgCtrl_Load(object sender, EventArgs e) + private void WaterMeterCfgCtrl_Load(object sender, EventArgs e) { nameLabel.Text = Strings.Name; Redraw(); diff --git a/TestBenchFramework/BenchControl/WaterMeter/WaterMeterCfgCtrl.designer.cs b/TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeterCfgCtrl.designer.cs similarity index 95% rename from TestBenchFramework/BenchControl/WaterMeter/WaterMeterCfgCtrl.designer.cs rename to TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeterCfgCtrl.designer.cs index f8db5cef5..08107ced4 100644 --- a/TestBenchFramework/BenchControl/WaterMeter/WaterMeterCfgCtrl.designer.cs +++ b/TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeterCfgCtrl.designer.cs @@ -1,7 +1,7 @@ /// /// Copyright (c) 2013-2015 Sensus Metering Systems /// -namespace TBF.BenchControl.WaterMeter +namespace TBF.BenchControl.WaterMeters.WaterMeter { partial class WaterMeterCfgCtrl { @@ -71,7 +71,7 @@ namespace TBF.BenchControl.WaterMeter this.Controls.Add(this.classNameLabel); this.Name = "WaterMeterCfgCtrl"; this.Size = new System.Drawing.Size(300, 200); - this.Load += new System.EventHandler(this.EntryFormCfgCtrl_Load); + this.Load += new System.EventHandler(this.WaterMeterCfgCtrl_Load); this.ResumeLayout(false); this.PerformLayout(); diff --git a/TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeterCfgCtrl.resx b/TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeterCfgCtrl.resx new file mode 100644 index 000000000..1af7de150 --- /dev/null +++ b/TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeterCfgCtrl.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/TestBenchFramework/BenchControl/WaterMeter/WaterMeterFactory.cs b/TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeterFactory.cs similarity index 92% rename from TestBenchFramework/BenchControl/WaterMeter/WaterMeterFactory.cs rename to TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeterFactory.cs index 1a5e157d8..f3f4a33e7 100644 --- a/TestBenchFramework/BenchControl/WaterMeter/WaterMeterFactory.cs +++ b/TestBenchFramework/BenchControl/WaterMeters/WaterMeter/WaterMeterFactory.cs @@ -3,7 +3,7 @@ /// using TBF.BenchControl.Generic; -namespace TBF.BenchControl.WaterMeter +namespace TBF.BenchControl.WaterMeters.WaterMeter { public class WaterMeterFactory : IComponentFactory { diff --git a/TestBenchFramework/BenchControl/WaterMeters/iPerl/CalibrationStruct.cs b/TestBenchFramework/BenchControl/WaterMeters/iPerl/CalibrationStruct.cs new file mode 100644 index 000000000..ec7da66ee --- /dev/null +++ b/TestBenchFramework/BenchControl/WaterMeters/iPerl/CalibrationStruct.cs @@ -0,0 +1,143 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using System; + +namespace TBF.BenchControl.WaterMeters.iPerl +{ + public class CalibrationStruct + { + public static readonly int Length = 35; + + public Byte Version; + public MeterType MeterType; + public UInt16 Calibration; + public VolumeUnits VolumeUnits; + public FlowArrow FlowArrow; + public UInt16 FWVersion; + public UInt16[] TargetField; + public UInt16 RecipMeanCurrent; + public UInt16 ThresholdVolume; + public UInt16 ThresholdTime; + public UInt16 FlowActivationThr; + public UInt16 VolumeArrowThr; + public UInt32 CalibrationTime; + public ulong SerialNumber; + public MeterSealed MeterSealed; + public byte CheckSum; + + + public CalibrationStruct() + { + TargetField = new UInt16[3]; + } + + public byte[] ToByteArray() + { + byte[] result = new byte[Length]; + + result[0] = Version; + result[1] = (byte)MeterType; + + result[2] = (byte)(Calibration & 0x00FF); + result[3] = (byte)((Calibration >> 8) & 0x00FF); + + result[4] = (byte)VolumeUnits; + + result[5] = (byte)FlowArrow; + + result[6] = (byte)(FWVersion & 0x00FF); + result[7] = (byte)((FWVersion >> 8) & 0x00FF); + + result[8] = (byte)( TargetField[0] & 0x00FF); + result[9] = (byte)((TargetField[0] >> 8) & 0x00FF); + result[10] = (byte)( TargetField[1] & 0x00FF); + result[11] = (byte)((TargetField[1] >> 8) & 0x00FF); + result[12] = (byte)( TargetField[2] & 0x00FF); + result[13] = (byte)((TargetField[2] >> 8) & 0x00FF); + + result[14] = (byte)(RecipMeanCurrent & 0x00FF); + result[15] = (byte)((RecipMeanCurrent >> 8) & 0x00FF); + + result[16] = (byte)(ThresholdVolume & 0x00FF); + result[17] = (byte)((ThresholdVolume >> 8) & 0x00FF); + + result[18] = (byte)(ThresholdTime & 0x00FF); + result[19] = (byte)((ThresholdTime >> 8) & 0x00FF); + + result[20] = (byte)(FlowActivationThr & 0x00FF); + result[21] = (byte)((FlowActivationThr >> 8) & 0x00FF); + + result[22] = (byte)(VolumeArrowThr & 0x00FF); + result[23] = (byte)((VolumeArrowThr >> 8) & 0x00FF); + + result[24] = (byte)(CalibrationTime & 0x000000FF); + result[25] = (byte)((CalibrationTime >> 8) & 0x000000FF); + result[26] = (byte)((CalibrationTime >> 16) & 0x000000FF); + result[27] = (byte)((CalibrationTime >> 24) & 0x000000FF); + + result[28] = (byte)(SerialNumber & 0x00000000000000FF); + result[29] = (byte)((SerialNumber >> 8) & 0x00000000000000FF); + result[30] = (byte)((SerialNumber >> 16) & 0x00000000000000FF); + result[31] = (byte)((SerialNumber >> 24) & 0x00000000000000FF); + result[32] = (byte)((SerialNumber >> 32) & 0x00000000000000FF); + + result[33] = (byte)MeterSealed; + result[34] = CheckSum; + + return result; + } + + public static CalibrationStruct FromByteArray(byte[] data) + { + if (data.Length != Length) return null; + + CalibrationStruct result = new CalibrationStruct(); + + result.Version = data[0]; + result.MeterType = (MeterType)data[1]; + result.Calibration = (UInt16)(data[2] + 256 * data[3]); + result.VolumeUnits = (VolumeUnits)data[4]; + result.FlowArrow = (FlowArrow)data[5]; + result.FWVersion = (UInt16)(data[6] + 256 * data[7]); + result.TargetField[0] = (UInt16)(data[8] + 256 * data[9]); + result.TargetField[1] = (UInt16)(data[10] + 256 * data[11]); + result.TargetField[2] = (UInt16)(data[12] + 256 * data[13]); + result.RecipMeanCurrent = (UInt16)(data[14] + 256 * data[15]); + result.ThresholdVolume = (UInt16)(data[16] + 256 * data[17]); + result.ThresholdTime = (UInt16)(data[18] + 256 * data[19]); + result.FlowActivationThr = (UInt16)(data[20] + 256 * data[21]); + result.VolumeArrowThr = (UInt16)(data[22] + 256 * data[23]); + result.CalibrationTime = (((UInt32)data[27] * 256 + data[26]) * 256 + data[25]) * 256 + data[24]; + result.SerialNumber = ((((UInt64)data[32] * 256 + data[31]) * 256 + data[30]) * 256 + data[29]) * 256 + data[28]; + result.MeterSealed = (MeterSealed)data[33]; + result.CheckSum = data[34]; + + return result; + } + + + public override string ToString() + { + return string.Format("Calibration: V{0} Type={1} Cal={2} Units={3} FlowArrow.{4} FW={5} Hi={6} Norm={7} Low={8} RMC={9} ThrVol={10} ThrTime={11} FlActThr={12} VolArrThr={13} CalTm={14} SN={15} MeterSealed={16} Chksum={17}", + Version, + MeterType, + Calibration, + VolumeUnits, + FlowArrow, + FWVersion, + TargetField[0], + TargetField[1], + TargetField[2], + RecipMeanCurrent, + ThresholdVolume, + ThresholdTime, + FlowActivationThr, + VolumeArrowThr, + CalibrationTime, + SerialNumber, + MeterSealed, + CheckSum.ToString("X2")); + } + } +} diff --git a/TestBenchFramework/BenchControl/WaterMeters/iPerl/ConfigStruct.cs b/TestBenchFramework/BenchControl/WaterMeters/iPerl/ConfigStruct.cs new file mode 100644 index 000000000..5eb89d265 --- /dev/null +++ b/TestBenchFramework/BenchControl/WaterMeters/iPerl/ConfigStruct.cs @@ -0,0 +1,123 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using System; + +namespace TBF.BenchControl.WaterMeters.iPerl +{ + public class ConfigStruct + { + public static readonly int Length = 32; + + public Byte Version; + public MeterState MeterState; + public UInt32 TargetTimeVeryLowBatt; /// in seconds + public UInt32 TargetTimeLowBatt; /// in seconds + public UInt32 TestModeTime; /// Max. test mode time in seconds + public UInt16 EmptyPipeThreshold; + public byte[] PCBNumber; /// 5 bytes + public byte TestModeConfig; + public UInt32 RadioAddress; + public UInt16 TempCalibration; + public UInt16 AlarmMask; /// Default 0xA3F7 + public UInt16 ConfigCheckSum; + + public ConfigStruct() + { + PCBNumber = new byte[5]; + } + + public byte[] ToByteArray() + { + byte[] result = new byte[Length]; + + result[0] = Version; + result[1] = (byte)MeterState; + + result[2] = (byte)(TargetTimeVeryLowBatt & 0x000000FF); + result[3] = (byte)((TargetTimeVeryLowBatt >> 8) & 0x000000FF); + result[4] = (byte)((TargetTimeVeryLowBatt >> 16) & 0x000000FF); + result[5] = (byte)((TargetTimeVeryLowBatt >> 24) & 0x000000FF); + + result[6] = (byte)(TargetTimeLowBatt & 0x000000FF); + result[7] = (byte)((TargetTimeLowBatt >> 8) & 0x000000FF); + result[8] = (byte)((TargetTimeLowBatt >> 16) & 0x000000FF); + result[9] = (byte)((TargetTimeLowBatt >> 24) & 0x000000FF); + + result[10] = (byte)(TestModeTime & 0x000000FF); + result[11] = (byte)((TestModeTime >> 8) & 0x000000FF); + result[12] = (byte)((TestModeTime >> 16) & 0x000000FF); + result[13] = (byte)((TestModeTime >> 24) & 0x000000FF); + + result[14] = (byte)(EmptyPipeThreshold & 0x00FF); + result[15] = (byte)((EmptyPipeThreshold >> 8) & 0x00FF); + + result[16] = PCBNumber[0]; + result[17] = PCBNumber[1]; + result[18] = PCBNumber[2]; + result[19] = PCBNumber[3]; + result[20] = PCBNumber[4]; + + result[21] = TestModeConfig; + + result[22] = (byte)(RadioAddress & 0x000000FF); + result[23] = (byte)((RadioAddress >> 8) & 0x000000FF); + result[24] = (byte)((RadioAddress >> 16) & 0x000000FF); + result[25] = (byte)((RadioAddress >> 24) & 0x000000FF); + + result[26] = (byte)(TempCalibration & 0x00FF); + result[27] = (byte)((TempCalibration >> 8) & 0x00FF); + + result[28] = (byte)(AlarmMask & 0x00FF); + result[29] = (byte)((AlarmMask >> 8) & 0x00FF); + + result[30] = (byte)(ConfigCheckSum & 0x00FF); + result[31] = (byte)((ConfigCheckSum >> 8) & 0x00FF); + + return result; + } + + public static ConfigStruct FromByteArray(byte[] data) + { + if (data.Length != Length) return null; + + ConfigStruct result = new ConfigStruct(); + + result.Version = data[0]; + result.MeterState = (MeterState)data[1]; + result.TargetTimeVeryLowBatt = (((UInt32)data[5] * 256 + data[4]) * 256 + data[3]) * 256 + data[2]; + result.TargetTimeLowBatt = (((UInt32)data[9] * 256 + data[8]) * 256 + data[7]) * 256 + data[6]; + result.TestModeTime = (((UInt32)data[13] * 256 + data[12]) * 256 + data[11]) * 256 + data[10]; + result.EmptyPipeThreshold = (UInt16)(data[15] * 256 + data[14]); + result.PCBNumber[0] = data[16]; + result.PCBNumber[1] = data[17]; + result.PCBNumber[2] = data[18]; + result.PCBNumber[3] = data[19]; + result.PCBNumber[4] = data[20]; + result.TestModeConfig = data[21]; + result.RadioAddress = (((UInt32)data[25] * 256 + data[24]) * 256 + data[23]) * 256 + data[22]; + result.TempCalibration = (UInt16)(data[27] * 256 + data[26]); + result.AlarmMask = (UInt16)(data[29] * 256 + data[28]); + result.ConfigCheckSum = (UInt16)(data[31] * 256 + data[30]); + + return result; + } + + public override string ToString() + { + return string.Format("Config: V{0} State={1} VLoBattT={2}s LoBattT={3}s TestModeT={4}s EPThld={5} PCBNr={6} TestModeCfg={7} RadioAddr={8} TempCalib={9} AlarmMask={10} CfgCheckSum={11}", + Version, + MeterState, + TargetTimeVeryLowBatt, + TargetTimeLowBatt, + TestModeTime, + EmptyPipeThreshold, + PCBNumber[0].ToString("X2") + PCBNumber[1].ToString("X2") + PCBNumber[2].ToString("X2") + PCBNumber[3].ToString("X2") + PCBNumber[4].ToString("X2"), + TestModeConfig.ToString("X2"), + RadioAddress, + TempCalibration, + AlarmMask.ToString("X4"), + ConfigCheckSum.ToString("X4")); + } + } +} diff --git a/TestBenchFramework/BenchControl/WaterMeters/iPerl/ProcParams.cs b/TestBenchFramework/BenchControl/WaterMeters/iPerl/ProcParams.cs new file mode 100644 index 000000000..e8016a2b9 --- /dev/null +++ b/TestBenchFramework/BenchControl/WaterMeters/iPerl/ProcParams.cs @@ -0,0 +1,128 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using System; +using System.IO; +using System.Text; +using System.Xml.Serialization; +using TBF.BenchControl.Generic; +using TBF.Resources; + +namespace TBF.BenchControl.WaterMeters.iPerl +{ + public class ProcParams : ProcedureParamsBase, IParamsProvider, IProcedureParams + { + public float PulsesPerLtr; /// Target low limit of the flow increase or decrease + public string Producer; /// Hersteller + public float Qn; + public string ApprovalInfo; /// Zulassungszeichen + public string MetrologicalClass; /// Metr. Klasse + + public override void InitializeAll() + { + PulsesPerLtr = 1.0f; + Producer = ""; + Qn = 2.5f; + ApprovalInfo = ""; + MetrologicalClass = "A"; + } + + string[] paramNames = new string[] + { + Strings.PulsesPerLtr, + Strings.Producer, + Strings.Qn, + Strings.Approval_info, + Strings.Metrological_class, + }; + public override string ParamName(int i) { return paramNames[i]; } + public override int ParamsCount() { return paramNames.Length; } + + public override string ToString(int i) + { + switch (i) + { + case 0: return PulsesPerLtr.ToString(); + case 1: return Producer; + case 2: return Qn.ToString(); + case 3: return ApprovalInfo; + case 4: return MetrologicalClass; + default: return string.Empty; + } + } + + public void UpdateParam(int i, string strValue) + { + switch (i) + { + case 0: PulsesPerLtr = Utils.ParseUFloat(strValue); return; + case 1: Producer = strValue; return; + case 2: Qn = Utils.ParseUFloat(strValue); return; + case 3: ApprovalInfo = strValue; return; + case 4: MetrologicalClass = strValue; return; + default: return; + } + } + + public bool ValidateParam(int i, string strValue, out string message) + { + message = string.Empty; + + float dummy; + switch (i) + { + case 0: + if (Utils.TryParseUFloat(strValue, out dummy)) return true; + break; + case 2: + if (Utils.TryParseUFloat(strValue, out dummy)) return true; + break; + case 1: + case 3: + case 4: + return true; + default: + message = "Invalid index"; + return false; + } + + message = ParamName(i) + " is invalid"; + return false; + } + + public override void UpdateProcedureParams(Entities.ComponentProcedure dbEntity) + { + if (dbEntity == null) return; + try + { + ProcParams tmp = (ProcParams)(new XmlSerializer(typeof(ProcParams))) + .Deserialize(new StringReader(dbEntity.Parameters)); + + procedureParamsEntity = dbEntity; + componentName = dbEntity.CmpntName; + procedure = dbEntity.Procedure; + + PulsesPerLtr = tmp.PulsesPerLtr; + Producer = tmp.Producer; + Qn = tmp.Qn; + ApprovalInfo = tmp.ApprovalInfo; + MetrologicalClass = tmp.MetrologicalClass; + } + catch + { + } + } + + + public ProcParams() + { + } + + public ProcParams(Entities.ComponentProcedure procParamsEntity, string componentName, Entities.Procedure procedure) + { + this.procedureParamsEntity = procParamsEntity; + this.componentName = componentName; + this.procedure = procedure; + } + } +} diff --git a/TestBenchFramework/BenchControl/WaterMeters/iPerl/StatusStruct.cs b/TestBenchFramework/BenchControl/WaterMeters/iPerl/StatusStruct.cs new file mode 100644 index 000000000..e2878705f --- /dev/null +++ b/TestBenchFramework/BenchControl/WaterMeters/iPerl/StatusStruct.cs @@ -0,0 +1,160 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using System; + +namespace TBF.BenchControl.WaterMeters.iPerl +{ + public class StatusStruct + { + public static readonly int Length = 48; + + public Byte Version; + public FlowState FlowState; + public UInt32 BillingVolume; + public UInt32 ForwardVolume; + public UInt32 ReverseVolume; + public UInt32 SecondsActive; + public UInt32 SecondsIdle; + public UInt32 SecondsUsed; + public UInt32 UTC; + public Int32 ScaledAvgFlowRate; + public UInt16 PeakFlowRate; + public UInt16 AlarmState; + public byte RebootCount; + public byte[] AlarmCount; + public UInt16 FlipTime; + + + public StatusStruct() + { + AlarmCount = new byte[7]; + } + + public byte[] ToByteArray() + { + byte[] result = new byte[Length]; + + result[0] = Version; + result[1] = (byte)FlowState; + + result[2] = (byte)(BillingVolume & 0x000000FF); + result[3] = (byte)((BillingVolume >> 8) & 0x000000FF); + result[4] = (byte)((BillingVolume >> 16) & 0x000000FF); + result[5] = (byte)((BillingVolume >> 24) & 0x000000FF); + + result[6] = (byte)(ForwardVolume & 0x000000FF); + result[7] = (byte)((ForwardVolume >> 8) & 0x000000FF); + result[8] = (byte)((ForwardVolume >> 16) & 0x000000FF); + result[9] = (byte)((ForwardVolume >> 24) & 0x000000FF); + + result[10] = (byte)(ReverseVolume & 0x000000FF); + result[11] = (byte)((ReverseVolume >> 8) & 0x000000FF); + result[12] = (byte)((ReverseVolume >> 16) & 0x000000FF); + result[13] = (byte)((ReverseVolume >> 24) & 0x000000FF); + + result[14] = (byte)(SecondsActive & 0x000000FF); + result[15] = (byte)((SecondsActive >> 8) & 0x000000FF); + result[16] = (byte)((SecondsActive >> 16) & 0x000000FF); + result[17] = (byte)((SecondsActive >> 24) & 0x000000FF); + + result[18] = (byte)(SecondsIdle & 0x000000FF); + result[19] = (byte)((SecondsIdle >> 8) & 0x000000FF); + result[20] = (byte)((SecondsIdle >> 16) & 0x000000FF); + result[21] = (byte)((SecondsIdle >> 24) & 0x000000FF); + + result[22] = (byte)(SecondsUsed & 0x000000FF); + result[23] = (byte)((SecondsUsed >> 8) & 0x000000FF); + result[24] = (byte)((SecondsUsed >> 16) & 0x000000FF); + result[25] = (byte)((SecondsUsed >> 24) & 0x000000FF); + + result[26] = (byte)(UTC & 0x000000FF); + result[27] = (byte)((UTC >> 8) & 0x000000FF); + result[28] = (byte)((UTC >> 16) & 0x000000FF); + result[29] = (byte)((UTC >> 24) & 0x000000FF); + + result[30] = (byte)(ScaledAvgFlowRate & 0x000000FF); + result[31] = (byte)((ScaledAvgFlowRate >> 8) & 0x000000FF); + result[32] = (byte)((ScaledAvgFlowRate >> 16) & 0x000000FF); + result[33] = (byte)((ScaledAvgFlowRate >> 24) & 0x000000FF); /// TODO: test with negative value + + result[34] = (byte)(PeakFlowRate & 0x00FF); + result[35] = (byte)((PeakFlowRate >> 8) & 0x00FF); + + result[36] = (byte)(AlarmState & 0x00FF); + result[37] = (byte)((AlarmState >> 8) & 0x00FF); + + result[38] = RebootCount; + + result[39] = AlarmCount[0]; + result[40] = AlarmCount[1]; + result[41] = AlarmCount[2]; + result[42] = AlarmCount[3]; + result[43] = AlarmCount[4]; + result[44] = AlarmCount[5]; + result[45] = AlarmCount[6]; + + result[46] = (byte)(FlipTime & 0x00FF); + result[47] = (byte)((FlipTime >> 8) & 0x00FF); + + return result; + } + + public static StatusStruct FromByteArray(byte[] data) + { + if (data.Length != Length) return null; + + StatusStruct result = new StatusStruct(); + + result.Version = data[0]; + result.FlowState = (FlowState)data[1]; + result.BillingVolume = (((UInt32)data[5] * 256 + data[4]) * 256 + data[3]) * 256 + data[2]; + result.ForwardVolume = (((UInt32)data[9] * 256 + data[8]) * 256 + data[7]) * 256 + data[6]; + result.ReverseVolume = (((UInt32)data[13] * 256 + data[12]) * 256 + data[11]) * 256 + data[10]; + result.SecondsActive = (((UInt32)data[17] * 256 + data[16]) * 256 + data[15]) * 256 + data[14]; + result.SecondsIdle = (((UInt32)data[21] * 256 + data[20]) * 256 + data[19]) * 256 + data[18]; + result.SecondsUsed = (((UInt32)data[25] * 256 + data[24]) * 256 + data[23]) * 256 + data[22]; + result.UTC = (((UInt32)data[29] * 256 + data[28]) * 256 + data[27]) * 256 + data[26]; + result.ScaledAvgFlowRate = (((Int32)data[33] * 256 + data[32]) * 256 + data[31]) * 256 + data[30]; /// TODO: test with negative value + result.PeakFlowRate = (UInt16)(data[34] + 256 * data[35]); + result.AlarmState = (UInt16)(data[36] + 256 * data[37]); + result.RebootCount = data[38]; + result.AlarmCount[0] = data[39]; + result.AlarmCount[1] = data[40]; + result.AlarmCount[2] = data[41]; + result.AlarmCount[3] = data[42]; + result.AlarmCount[4] = data[43]; + result.AlarmCount[5] = data[44]; + result.AlarmCount[6] = data[45]; + result.FlipTime = (UInt16)(data[46] * 256 + data[47]); + + return result; + } + + public override string ToString() + { + return string.Format("Status: V{0} Flow={1} BillVol={2} ForwVol={3} RevVol={4} SecActive={5}s SecIdle={6}s SecUsed={7}s UTC={8} AvgFlowRate={9} PeekFlowRate={10} AlarmState={11} RebootCount={12} A0={13} A1={14} A2={15} A3={16} A4={17} A5={18} A6={19} FlipTime={20}", + Version, + FlowState, + BillingVolume, + ForwardVolume, + ReverseVolume, + SecondsActive, + SecondsIdle, + SecondsUsed, + UTC, + ScaledAvgFlowRate, + PeakFlowRate, + AlarmState, + RebootCount, + AlarmCount[0], + AlarmCount[1], + AlarmCount[2], + AlarmCount[3], + AlarmCount[4], + AlarmCount[5], + AlarmCount[6], + FlipTime); + } + } +} diff --git a/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeter.cs b/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeter.cs new file mode 100644 index 000000000..da14726c8 --- /dev/null +++ b/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeter.cs @@ -0,0 +1,145 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using System; +using System.Collections.Generic; +using log4net; +using TBF.BenchControl; + +namespace TBF.BenchControl.WaterMeters.iPerl +{ + /// + /// This component = instance of this class is a placeholder for a combined main watermeter + /// + public class WaterMeter : ComponentBase, GenericDevices.IWaterMeter, GenericDevices.IRegisterReader, IOperation + { + private static readonly ILog log = LogManager.GetLogger(typeof(WaterMeter)); + public override string ToString() { return string.Format("iPerl({0})", Cfg.ToString(1)); } + + readonly WaterMeterCfg iPerlCfg; + + public float PulsesPerLtr { get { return iPerlCfg.ProcParams.PulsesPerLtr; } } + + /// WaterMeter producer + public string Producer { get { return iPerlCfg.ProcParams.Producer; } } + + /// Nominal water flow in [m3/h] + public float Qn { get { return iPerlCfg.ProcParams.Qn; } } + + /// WaterMeter approval information or signature + public string ApprovalInfo { get { return iPerlCfg.ProcParams.ApprovalInfo; } } + + /// Metrological class + public string MetrologicalClass { get { return iPerlCfg.ProcParams.MetrologicalClass; } } + + /// Properties set by the Begin and the End form + public string SerialNr + { + get { return serialNr; } + set { serialNr = value; } + } + string serialNr; + + public string EndState + { + get { return endState; } + set { endState = value; } + } + string endState; + + public string BeginState + { + get { return beginState; } + set { beginState = value; } + } + string beginState; + + public bool Disabled + { + get { return disabled; } + set { disabled = value; } + } + bool disabled; + + + Boxes.IntBox pulses; + Boxes.IntBox refPulses; + + + public WaterMeter() + { + } + + public WaterMeter(WaterMeterCfg cfg) + : base(cfg) + { + iPerlCfg = cfg; + log.Debug(this.ToString()); + } + + + /// + /// Events: Event.ReadRegisterDone, Event.Error + /// + /// Reference to a variable for the water meter pulses + /// ReadWaterMeter instance reference casted to IOperaton + public IOperation ReadRegisterOp(ref Boxes.IntBox pulses) + { + this.pulses = pulses; + return this; + } + + /// + /// Events: Event.ReadRegisterDone, Event.Error + /// + /// Reference to a variable for the water meter pulses + /// Reference to a variable for the related reference flowmeter pulses + /// Reference to operation object instance + public IOperation ReadRegisterOp(ref Boxes.IntBox pulses, ref Boxes.IntBox refPulses) + { + this.pulses = pulses; + this.refPulses = refPulses; + return this; + } + + /// + /// Events: ReadReferenceDone, Error + /// + /// Reference to a variable for the water meter pulses + /// Reference to operation object instance + public IOperation ReadReferenceForRegisterOp(ref Boxes.IntBox pulses, ref Boxes.IntBox refPulses) + { + this.pulses = pulses; + this.refPulses = refPulses; + return this; + } + + + /// Start this operation + public void Start() + { + ReadPulses(); + } + + /// Run this operation + /// eventDone + public Event Run() + { + ReadPulses(); + return Event.ReadRegisterDone; + } + + /// Stop this operation + public void Stop() + { + } + + + void ReadPulses() + { + /// Do something meaningfull here + pulses.Val = 1; + refPulses.Val = 2; + } + } +} diff --git a/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterCfg.cs b/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterCfg.cs new file mode 100644 index 000000000..6e03c3c52 --- /dev/null +++ b/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterCfg.cs @@ -0,0 +1,60 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using System; +using System.Collections.Generic; +using System.IO; +using System.Xml.Serialization; +using TBF.BenchControl.Generic; +using TBF.Resources; + +namespace TBF.BenchControl.WaterMeters.iPerl +{ + public class WaterMeterCfg : ComponentCfgBase, Generic.IComponentCfg + { + public IComponent GetComponent(IList components) { return new WaterMeter(this); } + public IComponentCfgCtrl GetControl() { return new WaterMeterCfgCtrl(); } + + /// + /// Serialized parameters + /// + public int OptoComPortNr; + public int RfidComPortNr; + public int Group; /// Number written to QuidoRS to connct the watermeter to RfidComPort + + /// Procedure parameters + [XmlIgnore] + public ProcParams ProcParams; + public override IParamsProvider GetProcedureParams() { return ProcParams; } + public override IParamsProvider CreateProcedureParams(Entities.Procedure procedure) + { + ProcParams procParams = new ProcParams(); + procParams.UpdateProcedureParams(Name, procedure); + return procParams; + } + + /// Private parameterless constructor invoked by all other (public) constructors + WaterMeterCfg() + { + Name = "iPerl"; + ParentName = string.Empty; + OptoComPortNr = 10; + ProcParams = new ProcParams(); + } + + public WaterMeterCfg(IComponentFactory factory) + : this() + { + this.Factory = factory; + } + + public string ToString(int i) + { + return string.Format("Name={0}, Opto=COM{1}, RFID=COM{2}, Group={3}", + Name, + OptoComPortNr, + RfidComPortNr, + Group); + } + } +} diff --git a/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterCfgCtrl.cs b/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterCfgCtrl.cs new file mode 100644 index 000000000..635c9d1ee --- /dev/null +++ b/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterCfgCtrl.cs @@ -0,0 +1,100 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using System; +using System.Windows.Forms; +using log4net; +using TBF.BenchControl.Generic; +using TBF.Resources; + +namespace TBF.BenchControl.WaterMeters.iPerl +{ + public partial class WaterMeterCfgCtrl : UserControl, IComponentCfgCtrl + { + static readonly ILog log = LogManager.GetLogger(typeof(WaterMeterCfgCtrl)); + + public bool ShowMore { get { return false; } } + + WaterMeterCfg config; + public IComponentCfg Config + { + get { return config as IComponentCfg; } + set + { + config = value as WaterMeterCfg; + Redraw(); + } + } + + public WaterMeterCfgCtrl() + { + InitializeComponent(); + } + + private void WaterMeterCfgCtrl_Load(object sender, EventArgs e) + { + nameLabel.Text = Strings.Name; + Redraw(); + } + + public void Closing() + { + } + + void Redraw() + { + if (config == null) return; /// Control was not loaded, settings were not changed + classNameLabel.Text = config.Factory.ClassName; + nameTextBox.Text = config.Name; + optoPortNrTextBox.Text = config.OptoComPortNr.ToString(); + rfidPortNrTextBox.Text = config.RfidComPortNr.ToString(); + groupTextBox.Text = config.Group.ToString(); + } + + public void Unlock() + { + nameTextBox.Enabled = true; + optoPortNrTextBox.Enabled = true; + rfidPortNrTextBox.Enabled = true; + groupTextBox.Enabled = true; + } + + public CfgUpdateFlags VerifyCfg(ref string message) + { + CfgUpdateFlags flags = CfgUpdateFlags.None; + + int dummy; + if (!int.TryParse(optoPortNrTextBox.Text, out dummy) || dummy < 1 || dummy > 999) + { + flags |= CfgUpdateFlags.Error; + message += Environment.NewLine + "'Opto Serial Port Nr.' is not valid"; + } + if (!int.TryParse(rfidPortNrTextBox.Text, out dummy) || dummy < 1 || dummy > 999) + { + flags |= CfgUpdateFlags.Error; + message += Environment.NewLine + "'RFID Serial Port Nr.' is not valid"; + } + if (!int.TryParse(groupTextBox.Text, out dummy) || dummy < 1 || dummy > 10) + { + flags |= CfgUpdateFlags.Error; + message += Environment.NewLine + "'Group' is not valid"; + } + + return flags; + } + + public CfgUpdateFlags UpdateCfg() + { + CfgUpdateFlags flags = CfgUpdateFlags.RestartRqrd; + + if (config == null) return CfgUpdateFlags.Error; /// Control was not loaded, settings were not changed + + config.Name = nameTextBox.Text; + config.OptoComPortNr = int.Parse(optoPortNrTextBox.Text); + config.RfidComPortNr = int.Parse(rfidPortNrTextBox.Text); + config.Group = int.Parse(groupTextBox.Text); + + return flags; + } + } +} diff --git a/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterCfgCtrl.designer.cs b/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterCfgCtrl.designer.cs new file mode 100644 index 000000000..b9d044006 --- /dev/null +++ b/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterCfgCtrl.designer.cs @@ -0,0 +1,155 @@ +/// +/// Copyright (c) 2013-2015 Sensus Metering Systems +/// +namespace TBF.BenchControl.WaterMeters.iPerl +{ + partial class WaterMeterCfgCtrl + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Component Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.nameTextBox = new System.Windows.Forms.TextBox(); + this.nameLabel = new System.Windows.Forms.Label(); + this.classNameLabel = new System.Windows.Forms.Label(); + this.optoPortNrTextBox = new System.Windows.Forms.TextBox(); + this.optoPortNrLabel = new System.Windows.Forms.Label(); + this.rfidPortNrTextBox = new System.Windows.Forms.TextBox(); + this.rfidPortNrLabel = new System.Windows.Forms.Label(); + this.groupTextBox = new System.Windows.Forms.TextBox(); + this.groupLabel = new System.Windows.Forms.Label(); + this.SuspendLayout(); + // + // nameTextBox + // + this.nameTextBox.Enabled = false; + this.nameTextBox.Location = new System.Drawing.Point(135, 55); + this.nameTextBox.Name = "nameTextBox"; + this.nameTextBox.Size = new System.Drawing.Size(130, 20); + this.nameTextBox.TabIndex = 5; + // + // nameLabel + // + this.nameLabel.AutoSize = true; + this.nameLabel.Location = new System.Drawing.Point(25, 58); + this.nameLabel.Name = "nameLabel"; + this.nameLabel.Size = new System.Drawing.Size(35, 13); + this.nameLabel.TabIndex = 4; + this.nameLabel.Text = "Name"; + // + // classNameLabel + // + this.classNameLabel.AutoSize = true; + this.classNameLabel.Location = new System.Drawing.Point(132, 31); + this.classNameLabel.Name = "classNameLabel"; + this.classNameLabel.Size = new System.Drawing.Size(60, 13); + this.classNameLabel.TabIndex = 3; + this.classNameLabel.Text = "ClassName"; + // + // optoPortNrTextBox + // + this.optoPortNrTextBox.Enabled = false; + this.optoPortNrTextBox.Location = new System.Drawing.Point(135, 79); + this.optoPortNrTextBox.Name = "optoPortNrTextBox"; + this.optoPortNrTextBox.Size = new System.Drawing.Size(34, 20); + this.optoPortNrTextBox.TabIndex = 7; + // + // optoPortNrLabel + // + this.optoPortNrLabel.AutoSize = true; + this.optoPortNrLabel.Location = new System.Drawing.Point(25, 82); + this.optoPortNrLabel.Name = "optoPortNrLabel"; + this.optoPortNrLabel.Size = new System.Drawing.Size(101, 13); + this.optoPortNrLabel.TabIndex = 6; + this.optoPortNrLabel.Text = "Opto Serial Port Nr.:"; + // + // rfidPortNrTextBox + // + this.rfidPortNrTextBox.Enabled = false; + this.rfidPortNrTextBox.Location = new System.Drawing.Point(135, 103); + this.rfidPortNrTextBox.Name = "rfidPortNrTextBox"; + this.rfidPortNrTextBox.Size = new System.Drawing.Size(34, 20); + this.rfidPortNrTextBox.TabIndex = 9; + // + // rfidPortNrLabel + // + this.rfidPortNrLabel.AutoSize = true; + this.rfidPortNrLabel.Location = new System.Drawing.Point(25, 106); + this.rfidPortNrLabel.Name = "rfidPortNrLabel"; + this.rfidPortNrLabel.Size = new System.Drawing.Size(103, 13); + this.rfidPortNrLabel.TabIndex = 8; + this.rfidPortNrLabel.Text = "RFID Serial Port Nr.:"; + // + // groupTextBox + // + this.groupTextBox.Enabled = false; + this.groupTextBox.Location = new System.Drawing.Point(135, 127); + this.groupTextBox.Name = "groupTextBox"; + this.groupTextBox.Size = new System.Drawing.Size(34, 20); + this.groupTextBox.TabIndex = 11; + // + // groupLabel + // + this.groupLabel.AutoSize = true; + this.groupLabel.Location = new System.Drawing.Point(25, 130); + this.groupLabel.Name = "groupLabel"; + this.groupLabel.Size = new System.Drawing.Size(39, 13); + this.groupLabel.TabIndex = 10; + this.groupLabel.Text = "Group:"; + // + // WaterMeterCfgCtrl + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Controls.Add(this.groupTextBox); + this.Controls.Add(this.groupLabel); + this.Controls.Add(this.rfidPortNrTextBox); + this.Controls.Add(this.rfidPortNrLabel); + this.Controls.Add(this.optoPortNrTextBox); + this.Controls.Add(this.optoPortNrLabel); + this.Controls.Add(this.nameTextBox); + this.Controls.Add(this.nameLabel); + this.Controls.Add(this.classNameLabel); + this.Name = "WaterMeterCfgCtrl"; + this.Size = new System.Drawing.Size(300, 200); + this.Load += new System.EventHandler(this.WaterMeterCfgCtrl_Load); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.TextBox nameTextBox; + private System.Windows.Forms.Label nameLabel; + private System.Windows.Forms.Label classNameLabel; + private System.Windows.Forms.TextBox optoPortNrTextBox; + private System.Windows.Forms.Label optoPortNrLabel; + private System.Windows.Forms.TextBox rfidPortNrTextBox; + private System.Windows.Forms.Label rfidPortNrLabel; + private System.Windows.Forms.TextBox groupTextBox; + private System.Windows.Forms.Label groupLabel; + } +} diff --git a/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterCfgCtrl.resx b/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterCfgCtrl.resx new file mode 100644 index 000000000..1af7de150 --- /dev/null +++ b/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterCfgCtrl.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterFactory.cs b/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterFactory.cs new file mode 100644 index 000000000..e54c1c1f6 --- /dev/null +++ b/TestBenchFramework/BenchControl/WaterMeters/iPerl/WaterMeterFactory.cs @@ -0,0 +1,23 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// +using TBF.BenchControl.Generic; + +namespace TBF.BenchControl.WaterMeters.iPerl +{ + public class WaterMeterFactory : IComponentFactory + { + public string ClassName { get { return "iPerl"; } } + + public void ResetStaticProperties() { WaterMeter.ResetStaticProperties(); } + + public IComponent DummyComponent() { return new WaterMeter(); } + + public IComponentCfg DefaultConfig() { return new WaterMeterCfg(this); } + + public IComponentCfg CmpntCfgFromCmpntEntity(Entities.Component component) + { + return ComponentCfgBase.CreateFromDbEntity(typeof(WaterMeterCfg), component, this); + } + } +} diff --git a/TestBenchFramework/Properties/AssemblyInfo.cs b/TestBenchFramework/Properties/AssemblyInfo.cs index 7166e9981..6bdd3d4a1 100644 --- a/TestBenchFramework/Properties/AssemblyInfo.cs +++ b/TestBenchFramework/Properties/AssemblyInfo.cs @@ -29,5 +29,5 @@ using System.Runtime.InteropServices; // Build Number // Revision // -[assembly: AssemblyVersion("1.5.72.1")] -[assembly: AssemblyFileVersion("1.5.72.1")] +[assembly: AssemblyVersion("1.5.73.1")] +[assembly: AssemblyFileVersion("1.5.73.1")] diff --git a/TestBenchFramework/TBF.csproj b/TestBenchFramework/TBF.csproj index d99a853bc..6a6805fd0 100644 --- a/TestBenchFramework/TBF.csproj +++ b/TestBenchFramework/TBF.csproj @@ -92,7 +92,7 @@ true - + ..\packages\ControlBoard\Munich\ControlComponent3Munich.dll @@ -219,6 +219,7 @@ ValveCfgCtrl.cs + @@ -249,6 +250,26 @@ + + + + + UserControl + + + ModbusCfgCtrl.cs + + + + + + UserControl + + + QuidoRSCfgCtrl.cs + + + Form @@ -265,6 +286,42 @@ TestMethodCfgCtrl.cs + + + + + UserControl + + + TestMethodCfgCtrl.cs + + + + Form + + + iPerlCommunicationForm.cs + + + + + + UserControl + + + WaterMeterCfgCtrl.cs + + + + + + + UserControl + + + WaterMeterCfgCtrl.cs + + Component @@ -741,16 +798,6 @@ - - - - - UserControl - - - WaterMeterCfgCtrl.cs - - @@ -1348,6 +1395,12 @@ BalanceCfgCtrl.cs + + ModbusCfgCtrl.cs + + + QuidoRSCfgCtrl.cs + AskYesNoForm.cs @@ -1393,6 +1446,12 @@ TestMethodCfgCtrl.cs + + TestMethodCfgCtrl.cs + + + iPerlCommunicationForm.cs + TestMethodCfgCtrl.cs @@ -1402,7 +1461,10 @@ TestMethodCfgCtrl.cs - + + WaterMeterCfgCtrl.cs + + WaterMeterCfgCtrl.cs diff --git a/packages/ControlBoard/Fuzhou150/ControlComponent3U.dll b/packages/ControlBoard/Fuzhou150/ControlComponent3U.dll index cd9c6acecc36fbe95b4d1dd888d53414fdc2b928..85eb2f960d1d5d640996a885e5fac95feee59805 100644 GIT binary patch literal 397824 zcmeEP31AH87oRdBfO8a~9)-E#2Ko^Az!<=(qmA|@q$RMKd{97isSp?Z(n*B?47&z{6o+8dNfPe5L^A= z2B+^2ZE8L7&#mK+7`IKo@Y2o=b>G^lY;j@dxMP94#&-E<*Q}v;|5uRGWbgf1pMEmh ztH-Ceu6D}0@YTuBoL`vmh3bnpPF1=3%9+_YAAI}uq@*90)Liz{>N@AnHrBU2pT9zN zak0MOVoisMzeU}S_`|=$;J=QZ>zLcOaoU|v$2I%=ojuF%-<$nSzT4UQ1$%yrDfsTr ztBTCS3KcWpxGMUSY}JnmLmbCPyJ@<24{&a_)!$XETJ4tL<>~R9vc8x0y*Iu4xBu98 zcU0|)2ZkuBD6Y;7RFCounbf04=!f@Ch5q|uRxO8xeZm~o)52~qYF#(&+TnTwyvH<{ zdwgTFymNh9Pd&M_&7lc7(f@q4F{WzcyPet{+}ZitzE`^h46YfM*nL*FR{|<^pVud; zPtT#<`z}29SHI;>xBE3{bLIIHb!QK`?;MgGaOi{KKEu>0?=5@n#Vr{Lsgvsr7~QL$ z+t_}u&B{3C9X{nHcbFeA{RYEO{0bK2WG%zI1AD+mH-PgRW{IHvsS(fd2&>6G2x1$V>tGC}^*Q_9f^S12T;ut}f8_ z0Qw&we;?Xcz~}2A{~PeP0(}MeF$L(m;5`8Bbc1JY=)WCkP7vF6@aa{w39`MQuOsNW z46^@&_jjRPAMD-+x!&;n5#&@5-!dPD3Gc*=Vv?BQOfnP4q%dhrI*3LvCTb#3jKEC- zIedi2gV+$JEsz?5U<@#ZFfV}uBV%C3FsZQEm^%O76sjifU}C<}oMD1kW;*mlBQc;O zL*l@k)(lhKvRI_ZQ_pBC`WlGD-e_w@Osq}c-ijDTZ3<#jM=N5DL}K;2SP^S165G?& zida*TSX4aJVYE;OEST*&e3<}s5O*+zFuA8l8)nP4w$#2NZQ}G+?V+w23F`KX7!$%^6H8PEXt8vhfO$Ht~G^ z+eF&1gUPqAKA^NUuwyQ0cT?Kf4km3Md?eCV_*}@{C(r1YN>kx6wrosk5=ZzOTrCu4QsMChwW2hMqdVG$(p30r;RL6F!kiSZ72DcV znhIYjUg$(=60Z{uaY8u~nBJ13*Y@!urg*lzm8jqkOtEJJI5ed<<&?a1J(l2L@J83kM=QYZi`K-NhE@BWM; z6WW<7MwtmTcvp~j1+SiBXP?SQkn>Y8Dp;;mLGXm7 zLDdVMUEvu6&t@Q(shFsMG%MrrRq+};e}HF!B3p4B-oJoW4$_o=!s}wiX2mw}sX!44 z-VB51N_ZXz3bfH0SRO`RSCUu4Q4|11*h>N4LvTT+hIzol`xOXD0WMv^r zLIpp$cUB4_=GsI~iBfE?+1OBuf1)H}l*D%;OL964VniB=oxHQMB!1EcS*#pH4U#J8 z4G3i5mDR@9lZ_WS#3qRsTbvAM5#z;vtWBsS+9q)#mGz2@8NjRz8ztrzHQ^Jb@Cle3 zE0IJG>f)a$N5&P2j#wdFHY#kR1~T68mDs`v(06RJde{h&4$=@2cm%H?qXIr4;sK`# zBSQ)w8LNqna3zTlxvW);5XLr_{f_3@B`6@ttTUmBkjT7yTu(5n{yrkZ9l) zG^#)X5Nj7>MojF&JL@GIGt!ARHfHbzrLZ4L;XCUe##un(L_I8zjT76b0pC%cUlZ6k zkCQmjChEa=)^|2e@B#G#kG0CiSwP}MDyx^o2~t>R^p=$+(ULaN4AHV&@Bv~$8H^1) zg%(J_D@cGhY;1%Bl6-(15&zbonnFF0Q9-@p}5BZkY302!gq~?uhFbiY-eq46Zhn8(Y=Xn zsho>od$U-B)He2}wP_^s8V|vj_r#j4`9f02hpGjZ zpWyj?FOY!u?doq7Kd2zrlKyJN_9|@rg^kPwyax*y#or#c6}jB{Hp(MM0iP{`C!4B3 zmfVD#sW^)uf4dT_g_U3x1v$ucm3+loYHgE_79rLpU`YX%{Gm6T&5VK-94sjhRC0z& ztkp^)dkySxk~zVqHCGy!5C_znXs-a;D{$JeAFQlg)%gf8XPi_{2&_($l}7Lv<{;7N z0~&oejUcaqRbEtscR(K}lT*{=so>eWoE|UGf7tj@#> z59sZ|^#=a0e7~(A%kgr;7=<&Ast>q6ZqUb#>jS(yIAU<;;pjP+I5`)PbK&H!0H15; z{K@h8v4Iu427G=m{EOqmZafNhSW?j&z~|aIIUFB$^-&HS{}%AMcFrA+53!C?ar}RP z&$V;zaeSE5qu_{v=>He^TsxPLHrmACgrfMG4p7_S`NWbb#^}K3uAD^Dl=fN1u#bY98 z@G*o50(y`mJi#v8kK=Lu^q@D`u?pzdLq8Yj2bF|=)xeKn$4cOD0N0P>as8_11q0uo zshw99`r)w}jFcSo59A#kf#(Oj%3NQLPx=N!Yypgl$oN7IVI|1*fc`K#p?^i-IS`&V z+c6KIf6`(BPWv!$CADn^N#fA_@qDNA7q?CCeSev zY{T)XFUY|v;SF>bLXYSAaXhY{C*;Z%_V!NGQYSixEKd(ScQamHGByH%=jQl4mA?oE#}d+A z9Q#xBI%Et60bMJihm$djbSK9Flsroh2D-)($2-hDp+>mIRD*fw2=fW&Ni~XBo6NK7 zz*C#?YLWSgJf$PfPaV}Sl+5qyj#Xi9<9fl5BcxYjs>3=Wrq_gZgr$eVI5o-FfOU$c z*T8iN*SQ;T=H)G2v#PVad$?jFPrA;*+KK&gfPVwl_qMQ$z$xWrekVk z!wR2Y4KVbBl{^$?dF}ivfOW8ARAy>tS75^PD*=XndHzgzwht4L?*|xnh6+qXwii<` z-xo0M1U^i?Y!9YEzBgc8{ju%NG|cw`40`gsmky|%D z;MS4bu%;9+yMUSss|q~Hdqc)CyCH`o;2odH=P_!vI00wVvJs z#Or<~(cWQwAE_$Zi>&WUI?>){eV>DKBd!Lv_sv?|Ud`{f{QfN6kEQ#ybU#mpy_!A- zfVSxP0ImVx-6pN!T&gvk(@5_$QNR(m-VZ+iBcDs&hffIGXbU{?Gs349I}|7`s;L+( zwG|#JiG&3TWW|&T)B>NQno$%UN;_z9=Y&K`Oi>m<9Xu42j3o-xP$XfY?P2m*Spa-# zTP5Ka)|U2{w!t68eek^v>kEtdSR}1SaP0!J$VRRZw+a-Qa5SkxKAcsPoWf_*mS`72 z&V!Z1YJikEq-OY$0eq?jV;}FkQgQQu#^AfcgQL^f+FW@A=Z|c~ zI0W-7Q=vkd2whZoa5NLTuV{lbMJ`;`fsuiEQ)nQjT=W4v2R`V)-0R?4iZy;d)<&VS zzz0jvpXE=b_*ob`8STi2Dk-KYvVflnbcMQrWDR0a7XSyWDkej&r$El&D2e2p@JQtp zz|U1Q1-cH`6MRRFN*o1Q&_b{7D?9-~y%o9mZpMdWM1=;pSYr)vNv7eQw4wha;H!Y2 z348^`C)$(+z*SIOQZtkSY48a$3s2OBIfZwOL5EsN)Z`U=V@7}rV+3-^=Zs`d!kr>; z*}9NEm@|-LDIz+XQ-KGS#x;N)t6(n+GY(vqF6E-n7&%M72z|*Y03R_Df(%+DK@7&^VgC0v+ee6tHLQowsG}osY@NJLbgng#3{_V(gH2TwkT{ z+?e5aIJ0+tTmKX%20ab3i5Y;}I{^Tyiz;^~FWQ|Y`GwN=!bz^)I%+Gu4R z5!OX(>yWkei_opDf9#3~Ts$gh!%FcjYE2|u3vFw@@N{djaCFnUh&hng#`3o|YV2HP zEUi31BP(Q4-wWV->&4Sx#Vh;PO?kzXuB`mZXziU}8LhpS*A>&^>Ly+b#VsX#*TN;5 z!7mb;eZ#Sb_&2sn;K#JccN;5+)p9@GW%a9!KEP4F8sDvho3=9i3K8Shsbehs1`VUf zC;na$llICh@cnm2Jv_Q=G{bzj$R$4sewK*Q59ycyKZ5g04Ti~tUlVx%q|B=fGo~K= z9MTI6(;R+x!+-SK`+Bql#_CS7(LMWixUsy2cc$Lep;_||mxeWeIm36((x}#ME$-Al z^lRtWW+WV2p7tnU)#juBta;sdx#Gzm|N5)r=MO)M8GGd65wACm^8=Csk8bc{wh zA9p1yXj&c3n_h#Pt(n&%aL=GYA1`be+x6VxR~NsUxKHu3cfIIdH}C4eQ>Ih9Zn4{A zUYJ(CtJW31g=(p4Q4m2CsoIv5m(N2(S~cg<9iM|At#LnqPsQ>B#!jFp2g{Q&@YhqP zjfeHFv8N}#QqVG_eRAKIU*6$Xu}|cmYu%Ujp44^wxOb-{rk|^{sCM%;8%XzcK9s6I_Kg~EeUPAVZ!O9 zZZqF{wL$W}3T{WE#;qB-p-YA7wT@^*UmCr6?$q5GAVgRrGb zbtze)lRsYbZra_2e|WD9cyFn0(_a5iw?@tWp|8h{z@0TahqQ^mQ(^MtsS969dbsY( zH`exVw6rd?FaKLDI=aJ$tCoG(erNj!Q{QZz-y-_AVLKi!`?$Ta1KW0O_*U}T1C5Mr z*XuT2JN&7SZ>r-j-N(OFeH^sEy3=afw1tCP)Ecs2=z_mhjc(j}=2C%l@yFySkY z@6JuX5PUVu@c!##y?*v5VK@0S@zjS$&VM^GsKvUTw^fZ6UA|W{J^keQ({Vw&f@}S| z#PRsWwCer^iUwh|J6Aikc;&=u^)Kmiqo?!fX1Y{6y@M^o#(tjW!)0L_vfcNy*cmAmru_P-QTR|=S;tkpyY3F8SGi7zjLyCM6ddb{XWRt={R7n z(oqn>W6yWRY<9liSnRTJdOcT%2?dES?~2&0?0g`xXH2eU{Q4#RM%?)GUgxFN zJ1wnsU_qnVF)1&)&ph*8RqcD5oB4K5ObcDM;g9&xt|vA}pLcu^y3TP;X63OVzTa=2 zSL^K!1DxA6x*nrVPU;hLYwYzP?T{1zes4PXes;F;g`@5d4z1aJ?zLqrb?zNq4xUY3 zl#%7SEAvG7n#pT){~Dk3o7j5TDP`kp51Xm{;@|EQb4ockt#d|4#ifw9L!%=84!zR) zZjysA>Dm1p7`sizb=6}Sa4#E!|`UHRNRp{{;27Hy7tZLPpmvlc&|E0U z1CAKA85@nC1_U|HT($Y!pDM4p(+2grdH<@r*JAfdJx>1P<}mQR!wc6}`f!bEdqwZ& zm*;m{TK%h52L?{@oEz`6?&U@4@;H>op*#-Buknh1a28fQ%Rj&&uZQw_$o_nD$^8^@ zQO=&^aVU>Nc^t~ehw||u`@>lBdMK}l@_Hz*hw^$TuZQw=8~o8o`BNVGQy%<7H$^$S zlt1N>Kjo1><@xV?$|HXkFMk#C4I?H!V$#+b#e@#>JM9Yg#I=&tG%bpDvW`6ln@OJHuCfk{6w+}9S|IN9h;g54YEw`h|$+h-( zpG#n;YG0!F_FiT0^*ga>YU&let2*!6!#i8!hfX{A+6=X-$(fF$cKnz(dFj6&f7zqK zuBxMQ<1R$yZQFcmYNhkhcgAgq(G1Ht`hCkubvHyE3d^23_C#Q4{KJP2Yb1X-?$pG; zYKDH9PEU#OPydbiD|+&91V@yt(tJ>$44Vack5qldrze%yMHQMPz*;d#FYvvw;s_IzRE zcS|NMm=!-2_%97wt3bks83pGT3>xWC;PJ)eKkoGR-&b+^xXusfKHRnFzJvCBa`vz@ z?{B{I@m1x_n~V2VNcm{_*wozVzIzV;^!57Z62^H2tl#l{!UsVo26oEJ)U8?b{TJP8 zoM^qd*)-jn#mm2FUE{>vP0zUptXbSE;hmrpcRP=Fdo)$qyVCwQ8s_yrvF*O5-@v5o zq%+z6jrRYp8!`T)52tt9HR${Nxl`6$S@}g?jS~wuHL3k*>Wbl&3~x1TvE}?`=&(BJ zz)NRF&U$4lbZGWV#<%N#4*zH1mHdwLe*WlQzm&#_2cNs;vHR`h1IcGbe)P)6D0DdE z==z^4UB7`^dt7pRZP@V5_rgGHhxz~3IB~LPi=O$aI#U`A0}IdJ=mDMcKY!z;Guhhz zb!n%ob#cM6=hpvRA>sARDeD&x9I~R*uC3p-#@MP2S=eb;*!SJ0x%W7=YFUrn;YJ@B{qa zHlI(w)1BP4|GUY*UcEgjH>t(0=da)McH86r1C(sCZjI-P&e=;J1WcYb?Lg1LuYZ>_ z+DY4Tz4!k0lV=}}zZzKK=fE*7s?Lfz*mJ~t-(4GBQG0O3u@lRhzwO?3?dQr#ZQk3t z@=Vv9dcOTet{qo*xo%17ro-_gZfW1_bxre6$LB_Befwumz1#Z@$C>^YVk$+(&2;zu zG^$x-T*w_J`9!_t$8+Ck^mX;glOHh-Uo>q!D&p=_bTg$q(dCIQPjq>r!(rd!d|OA} z(d8Xo-q9t0F0y=l%npCU*y2g29_Ti|Ov!&O?=XBV@37*iVbf6PF$WLb;aii7d$?!m zo!YkA*Wu2vk#P&YaMe`m{86s=nRf=yJM{9~9;(Gh=PdKSSkdoQ&u{97P5bSC>MhYr z{LXLP({bSTVb{*R9#z3NW!Sa&-wyV!``nB>b7pm$o2xs0>TcS5M~)vz_#oGHN~aE* zj4nC)&y6!iGr6DK+dh4Klh?qfr{w!m@MF~$ z3lRkoJpT8k*7M(&I=vmfAKCUEoI_2x)Tw=~JG-~P>l+ik>fu%@kdF_8(c6dww?i2mr z?Q$%-*H!n4H7}iU4H`SU|-kN@nv=lzhxV?K9h zf4MTQPWP*dwT6UhTi!W2V_bdrnloCi^*FMy`m&a5{nc%fuPI`V`8|G#P_sGhs%%(-bF@xqrcJbH&oyNH@R$XSAMX_(0`JoLaGeb9f zU3Gc6hK9L*Y0fGC-;du`>ATF2>hAR8SBlJ6e4Ss3=^OI5)8Est?hkLncpKHPMCT^1 z&@s-9l#}#h8(vxR;J3I8|4UnAt6c24q1x1kfw#MCs5`SC=NHAG>tRBRo2<{`Y}xsy;n~bahFd=&PdGLHg_B z)2Wy0d8+aX+Wh*9+Ne($GU2r|sV}SlXy-S(^Czh%$Guii>c6iG> z!QU=Ac;?}yQSC{Hn$!%5P*6NWbkHi?qe|d69f|p^)xZtJjvORvv+`oCw>mTXvA3U^Z zr&CIX>gL9vfoIR>?w`JB=bRCv9h)O}c>be{+ZHoNhpl;SZbr(4FLJu?-nA^{%c%ov z|Nh>nqb;WQUJ>Nxd8%u>1G~Fs7)HPOUaV2M5BoXixVi80?RY@*ccNF_Q8~Z;dMNdB zkn^J4$xA>@o>Pwh8&`t9TF7(&H8+9}wCNk<-!Xkwi@80IbopiYo_DcnG&L80*}*$~ zba(8!fBJ;EeJ-n(x7f3>BN+YlP^-_wZcjZHa4vB@IDhlv>fbB;8+FC~W~~G;J8pFM zTl1?Xd^m4EQ9R&Wud9mX`}S-lJwG2Xvs(P-vSNK6Y3%qp<<{JZYmAzEzL+WqC8J&I z_`MJrh7X|}2-0mjcc@i6Ob+y^etU@;l7e1Of~15Pr&gz%Ux#=HC>CPZ4jEH2mvpJ# z;|uN3K5Mn+9ju*4jysklE~-g|TW1>ocJNTj3h%F+uWo?6)i}^(L~^Y& znW}@RX5l!;8}XH9n@WCQdAq0~k*7L=1FbII)98}DPG599*BzP%e;cQ1b1Z26Z<^7l z^{(pECUa&SS*2MYbpDH*?Zc~2G2UL>^T>pq&3rr-wA`ELksEpG%&CjjHZPvA==qq# zv9&MPNOfzK)oJFrlQ5!pEz$06@+fZm#BzkB)Zz z_rU|rgzrN4Ubs`|)YG$o$h(}p%a!||s*ra%d6z5x-YD;K@-8R&g(CS}PCl1|W3}>e zYg@Mn(Ouk9;mCpUcVTa`F{R`HH1{#ZtavY1du33i)$6`E$AWF@r~@ z4C#_QzGsPjRYX3Qlh5Vkb2<53PCl2D?>>2U?>_M?(OaZ;a<@pW{AD5BBIR(Wpv|g% zbAmQ)to2^h@#OW+TeZI&J#h2%%E)h1)?DdaRoidPhGA=W)M=!e+4h^r?pqG#HV%yo zs?#UvAIJSMifOxJ-BNydYrvXA-L${PyczJbZ{@4&*VK8>b;m~fI%;0R*jqI>DcpC3Cf^(O?%b5c$tjxp zF1@) z-|LMpmv7fScQa3M?wyx*>hu%+lG{Yx4?i|JGxxb=51B{(Z+k6Wbx(CaE#$81eq?Tb zQb>jLlwtVv+Sl}5U60qVUFaIzsl}_WZ&JS4a@y{B_bc>@J<$Q&*cCssVb;#w)8BBb za7hmi=XBrX*zoweWdp)v8m*hUV*T;o2W^_w@TY0ZdcCh~^o8fRjz1sxe$5}UAb?ww{+OwD>hsssgpK7%JIm6hQ%IaslLlO*-RM*a5FX=g9ZKcruT~5R# zz0}-ychsxjMt!|xRnvv!eh1GT?kV#94)R@n@?Cu;cJ?5ztMaVhhp-bOY)sd@|{caolEkaOY)sd&+eT|@-8Rua`G-G z?{e}kC+~9dE@#&T2l?0Gc?n$={c= z>o8gVrEmE!@apAX`j-C!ulyHy<-fqoxZ?R#`S`PM^0}ORE+?PM$>(zNxtx41C!fp7 z=W_CIpUA&`vgqKMhnG%WYMc;w?+aKHF0GGA{qu)YsyRKs?0U|-^7-Hj#+;W^M#$%K z^0}ORE+?PMIs1f+o3(kJdiBU(#yb7;L;aBhkJa8AxoJw3!$bSTIqzQo$?$V426*+l z+xdE4`yZDb-qOGOME`fY9EGVuFC7GyspaYYRUdBZFyal*Hw94mDg2y zU6t2W`L8$2f4%wD_--BK@370?VVA$dp8B%-k9K~uJAaaTa@=bLHQsr&qx*y@L48{0 zYlpYI6a20GDdOCWl>O5u%X0m z`BOysQ$+bwMEO%hN-NPI||+l`?Pb)#bHj_k6WQ?yC6_wKTofuD&19{>SWvTaA4ZE;LE~`q}*y zQU0YC`IlPcUuuzmsYU*!7WrNod6%>6wq^M*D9C?7LH-L0)iy7lut@$33h@0y`7bEQ ze?dY13kvcT%U_1?d3W)b9lX;=cgGD$?YHYwfgNAu+S z$mILT%HZ_ivu_`bWC^2M;aU>6DV8y15a)R&zdg|MW#W=ZqNb z*c`dT^B-N5uaU{u$mDBeMZQM16MnE>SyJD8Rrc%@8{IQw;IGT(r5>*5s>&;9^XrFg zJJ(a*X#T3MvwPDQM$}nyHuIos&g@@iRGBz!_Gp)z*-1_FCtpZBs8~JCrGM10|Ft-v z_TRf^{)@wZa)?Nuy7Ig2JHq;BPmA0XkTh=3xtYV`TYMH+FRMb|&10vxOuz%Xk%&=JxQ<6H3J5pgxlQ_3|``Vt|)FSEC``bTHs&^zHJ@!|J zMc#jYzc%}`b4hh(wc2)M@70E558cdqGwG54tw~>9t9LHoxy0dXgFo54*Vpgm+0Dl| z*1olW>7c*=OwK;Gcl!6akJ{$Hzy9~u&(HPy-|Q*#b1J7VYdz@X_WYTb3~nCHZuw7f zy}4)UqC)|FZr9&)so#M{H`lD2IVJPs;A-)A4i|iL;Zn|nE^}tSR69TaXx)oLn)m-| zsrzKzqJk}k#;;%My!`z`<8F@bbs@Fe(dC=|b@^nBro|Y?Zo!T}j+_~J^VFNoT{e2Q zeRuf911)xLIGO6caa`!VJ*wxw3wW#TwMw6zxw#|wdPIgx-=6}~+yCmEczE5-#bMV| z-|$HeKKae>HPXe42W>a6sy+L8$r;c`V9qrJ7s^0d|AG(}e zKX>i!uIh^tj<#_fWft&|PN(u>4s8-&MJo^!v2^6P!N2=-l`>$9LA}zVcA;vSgKcli?;`4buW6B+pvnUXzCl|Sj0*VU(NU2Pn$V3aXk@eLo1;Ta0gHQZCd zR0PC6j<_=nKKTb8fy)m$19ArB49FRfGazR`&VZZ&IRkPAPAt|J+fTzpAu^#!k>#KqVDU(jG)!9pozmKLGD z7N>BTx$*QGDzuc=1j;648}$Xp%EpJM*NU~;*-tO+*x7wnc$GL-+SZ?H{gPZ2xml`7 z5Gu<8b0jY=!JpEw`;_XmQJoTD zm3Ugr>nl%TYe_DV3Kpuwn)MQ)vxn0XAA~VbA|{?jC6a`ccC++SWU;;w4qM{Vvs<1u zmsB;a<<^@1(#Q$x1H4L%{%7ke$wP6P)^ck@XNi~Ch7VBU5;s?#71~HU%`%@0G?&Ig zZdpLHY~Yej5$%J-=zprdlGv>^AFEPu9wPm3O|O_Qjywg{dAoHKD}R#un%gaw_Hx|W&h$zv%NEGa&U`h^l|0@)UW{4x zAFQvP#X&J^1+r6xweAwSecDQ7u9(kXFfNRN5;5^)mDra{>y>3oW2Y8L9c?u2Q&{}e zSzI@snflt7#lngUWwP^Oqo87z#c5^HNHI%nvA$r4EpaiGKiTdU(`A7u&b;L%+Cn!= zBzsg588+=@P-Sa|p6dEqO1%Xdrq|AjSmk4-CRS#x z^;j9UQD4yiSgM|^u(fPR>3mA1Gsrews>Mp%wi4@H8>^^AOZKOluCMtNwqMVam9&@y zb0Vbi@yaSx#9Ws}iXi`(K&UTzXy3!mgg*oIwJ#qGo5S*7-;yn{?fOFM>>MXgMC`FD zTb}D{dDPh#-eYCneDKf%;IUMdwy=HC;{Yvz|8^QH5nHqp`|R4EYV-Pn1);?D>nUwX z`{FL4;zGjhe9)ySDQur`&!%w!p|2aE&;0wUg<7?%R_x7E?I4sMv|=>6EjM~ zG_6x?&05PwiG`)uye|~pM#s`-nfqgzLT94{v1Mas)DpC4O_iBViv(-s5b6s+((y^v zSK@}%rnQ8W2;HhxF{4Cm6{f^|brm~dYMEELyw%s_t8G+RPKtYqWZSyHEp0c5eyDGe zOKhXQ5QO=7C{>D(wn9J|WVH|vcy<|hLVdQ#TP@_Bt`S{d^Cg;=ELB{H$2^-G$z_mL z-eMu|W#Eaqi9&qh*cR($-jyBz7P}OmXl~Rp#XQo|qgeL9j9PjQSl3+SwHhjA-nX>t zYnC!A1ncn@cdNCi*@_oZvcuP}y1+w#3DputIlh zK1k@SGw^C*ewB7&C9YU&mbM#q>bK^em=5_DrmC33u&EXbR2(4DY_(};Xr&}()h#ij zl&lv)t=KPXEo=1!c_?vl$_jn08I{tD5M7CPk@{q%UE+3&snCj>5;9a-LV;#6>uavi zGNqUSmQ;7k&Y4k5%3KNRG4s(P!Mw!9sjo#77KkMnW-(P+aLy8`m{v-mJCw=;w&0JQ{)@#Px4z=u)?0#CUbk4qNm@ zIuNqx*b^t(>HQP;vrq@@41^c6r@p*wVef_d_5=kA^PS^AK@aUSU4-q}c8TpwOgWvl zLelIELy#}80P4#=>d=b2o#AUl#1pVc$i|qgfZh3RN2>uAMJT54Lt@6{w&S1-r!$tGN&M>Ws70qaQ z=w&S;3B5eHT4Wz2u@tRYWb041qn*J%StpBZ-OlLj7b~(SPpYGxp*<=0ieuN#&>mN; zI4+faUpu2Kd&i1t(Z0CglOy{C#Ztxett`8X9k<#lOP7jo%W4=R2K%v~h-81G_)eCM z20J4v8)u4d#lCQa4}2|__%S|pD!#*|t--#8JmC+y>`a1vu|WB3*B8`0J0-R+Cr?3r z?F$472MZ;Nu!1~f0I zgko_urtA9@m)J&LXqNpsFB?hPH|tnZM{7-s^#!eLiG^O)?T9&LlL0%eh+VVVvQt~x zh*|Yg#1QIIC}8VrzDi5#%jyx?u+b=+R1|8(hKDq(P(5WPKzn5!7g|$VKv;^+^+C~T z$;T@(s4KIySTkfEl0}NO?qx~0=$Iv6k%c?_S2HmBMvDgu7E!$PF%`HxShYlTT%_S+ljPu5tlR9CgU5{T02o2biQDU%E8cCJ}V69mira`BDk7CyAal6~7FZlbo+E{t}0xg9S+iAEo z>T93rqUEzVy-K6L;E#Rb5~&i*ww+c>(4yUu7NsaUa90328)yY!gO=|;+S}viwlK=`kI%x`1J+NcIF<% zikyEtZ4_0%d1kB`EW#8hn=WiA&D|ztf4s{b79BR%Y?V@kDp=JeW)wj)bg}PYG3xR| z6sD>qnv$w7L@Lp2tNFNvu%(OQJ+4~2eJ($BwC0Jm`a*V~#MXK}E}hDCVeqkPQJ6B0 z|5!Soq2fZBg!%%IWUB=03x*`h3u)R}kwUcaY&*3*j*}&uoX4Fn_RE)9eIX(6;4^N= zyFEp*Lk)`9qss2$+MnCT5AW#f;ISPOHSnSztx;*Q!PlqnNRj+wQ_rEQ+>F>I*rM7%ik}zdSn_?3ORL)hWJX z_SDx}+KX@fu}f^t6$xFgEMFUI^@W7N63t3Uk|#8I9VPHC=qyW60)9VLDkQmu`dZta zS;>+OPGY^Znf+zp9WMQGAt zK6|*(gxn*KoSd9OB?W=f&XQoLn4q-%EGPO4%@R}?>T7?A%OI{oeJ)g>44f=iCJIeR zxvDRlxD_7>&Q(D_6 zw&oeLNO>Z0nS1g?+$gt3>H69@_c2eSIpvAOSWet{BC*?JR8rsKEZ6p!D-9V*iA%%8 z)2q{BeT%juKfOtKhCR1d-y%%pXE;mGaA=a%&qnhZPQtStnvI&$tY zJ_FBufELRt5TE(*pZNf7A9OwQ;r~Yh6eg?${71t7FN7(nEZh7q1pXh1QLgVZUua2* zVQYToL;kM?$R2J9um831<#^=`$Qh6`AZI|%fSdt21OJf>xcsGJn3KnHK2g9S{t|eO zOdOwS+kr;JMGttTd@E5Rvr4xb}9`B-DpxRli45iu$0qmo94>&4`vI94xmSfgQ0hSje> zv{AjJ$fWq_SonYEwYuMfRi+u(_UyuRXF4*yn4U~L(~W6|bS8>;g+m3s!-p%n+oQz& zaX|eQ#A>9=#(Y7rk2wz3w8Zk;;DCct|XKAjxlbxX?2 z=iyC}me3)F*?zL>HE5`ZM|X{8m=71Z{m+j(@y=h7I){V+ZiM-7|cZ)_^ocZ!Yf znKAIj;?vs?>s{O4yY}$TgiD>;*SfQN`@6m|;j2DAbN~M7W>YlIJ|W{~ZC$x58Z*RXVF0lJg{+~ZTwD$PV&U@YuNj&CrclMVnzC%7^8fw#ZI!;u{HX3uKYpdie8t!Km6*OEe>?p>{p$YkHjKAX{YrFh;tCz(+(B$@4( zPg-}`_xiRWTSBKs&UkfcV*0U5w>-k5^Xh*e*rqBJk?GW~TkQ6j7pA!|ObumdF2lfp zsEz-Xq3{hW(%6#r51>pKPU^I~h+z1r)9xXH(WFkhk4Oy&dim5-FrJ|Hs)F%iCSw=F zzrfapF^;u)-ZjEQC58u5-gUx5wT3(??=QkbLxy}4Psw$uRiS>s2!*-FT4abn zuE4)R_@N4(!~1d*>8D^gD?P9q6ycA0uIxL zIfXeeN^O{e#LD`03uRT_%%chrZxzR>_{!&34T>?-KJ}DLL(qGh=$+sQWP=7?Tr~3` z5op8BIou}{x`w$Z30q@uB7HR^uf4%}qDz_P4CG0uKx(53*k}tj?w}1uX>b7<*Dx<9 zgDU_Rjlm7xwC8IuP6l^CZq9YCFz0=pz_cH+u5mI{hV(GZIbULuQ9zNE@ULbq#uwBw zs6QIs|EBc2g!yQQeyyX*-~nne07gSBxH{Fj1Qs-`1y`qVjfS^?t_%8Wg_-ns0{TCc ze%CO6-hY+B6ZD6ANu#)6I|`GXI(2zFDkcW(+@!I(*Bl*KvyFQ?lVI4m3T zUjf~AbO~cLFb~zRS24^3lyeYj9PKd12@>MM)da?zJNTjr1(lB4u+T6)<1oez1YAwS z!W9IZLaPt~4QO;Aj-dV#(8{CqLxp=ejB$s7!s`c$P6PeZVBR@~JknHyw=_TSG86_q zOs24~V8$U7W_uVV1gUULtAs)@WkCq`D&D4&c>`u)K4sI#)626NE?W+U%FxB7=}^EL zLlwZT8beihBNCkn6*PspX$;kXYS1A|?aXF|$b^85GF+vqqw)(=_%l9UUS8pSl?y-i zKkMV*=jGtz?&B2JTIuEVrjJI2uZ~`7FO5NudQh~AvzKFNAZHMVdJtfS@pWOsU@&+& z`TyYK-1hqBaCWXE5yS=jH6<;o}xISncIzsE*pT zURo*wS7>2aJ}zD^oCb6z419BCeS-v{Z!WBFK3+az-+aKfmm4_e=H=$)L7ZDAIET_6 zTqJ6Z0Wt&;!NUorIA;w+n$Ld(Uw~(8G+9`uRFl9jwNgC^28~+jFbT#TY#umnU=%P9 z$@rZ>L?#f42`HfAMk1LfDBBcdAEB&@3|y@vYZeAp04$TJndh5z1)C_lj~HqJJ*_spxM(s_l9lJ@se%DXTtGn&973sCdJRUIi7nQaim3r23X};2 zKOBwMzygsrfcILm)46EUVI5Ym-I;!AH9;;k9JuMQe^qZ{9I4I=g<&H0%$oLL2D>BcYEsLCokhd6-67l{yOgx< zE7M?s*G{Ttf`KL&Y=YGh8bCFqt~TubYUXbk50GCNQ#e%I{Cw1mv$r}F7JMyBGI#(a zOalyA?IQ)Ok&eyqywXqW$I?*(7gU$94uqgFz@ZAvE(5HQS`-hjrEw%jBt9B1O}IZ1 za->8JuwX&59Q}WQSB?JsDc};!$h1Jj4OtB9iq_DW#leXGfMZvXsg4+iy&w`) z6Fo0bcrYb1l)}R(Jc7b6Qg|ebVK31dQdtc9fz~jZ#kCM$gykM`OYnILpQZ436h1@Y zQxrbQVi@#V!!ZgUr|_4Q{1+5HLgCLSoJHYJD13mz+bR4$g;%qf__KzhFQe!yD4apb zyh7m@DVdQJJ(a?vDQu)LT-OqE8$;n(3b$u5@v|dE?@ZC-DBO*biKlP^g?m!CH-%eM zIEux@Zc7R`pk(S%xHg5uDI7uJsuZrqVxnJ9(LE{bO<`XO`%xGU3xyoQsgr==bYH-5 z93tQ!D13&(rzm`q!uu$EfWn_pcn^g?qVW3^ev`s;D4faSFq{{!Q1lE6kEL*L3iqXO z9EIULM~Js0i;4aSiVo)`f()EK3RufxQkRR=Ish9M$`C#0Df&+oKFea#_Xmpp1%M!Z&P?R zh1XDc9fj9ZcmstuQFsf5->2{_3eTbNTo#jhZD%pb{|-uKCxv%YGM`ZNEQ>||(Ws;_oCOPXxOgaFCkne#*qz0sQgGc(kcUfS0`{YDMG9ADaRlbM zDn+kGVLgSbvzUy88WcU0qSvPA;S`2*UBRCQ6mH03a#Yrw#Uz#}3dd0Lu@r7k;dlxs zu$cJSlf~r7wjV{GNa4v8o<`vr6rROmGT!D=^!XHCNa4j4UP|F*EGBwZQ1}fBucq)C z3a_K^dJ1n~F^P8*g||?6JB4>pcqfH-Q#gylpRt(ue1yVZQ20v1F!XHrhLkjPr@TU|$L}9q% zD8vh&ISLrAI0_g(j}b6j!xk`HV-~Orh2h$tK!=Ne0uG^YO$tX+xDkb$P`DX|`%riQ zg@;pk422g__;m`erSJz7{*c1ED9jBy}+6q{P)+WB84Pd1Ku4OwKqRhx}RofC7E~i@} zzh#-6W|{o5W%4M?lm(3=+K6dJhoQzmDTvGHu9ISO5%u<{-h(08!$sA?jdqk2b`Z2z~|#7P&Y#OfyKI zh3d&PiZ$`QmAWCip%O2#V?_hxhSy>Qje^U_g*oo2^OZVF48qaA;4Bi1y|8b4lQMq; zq!%^gB=t9RG&R7Pwz}aGXHd%c9AzH~VBc5gCbf?oJ#2M?ebP4t`$Fl^BrX8L%7zW7 zRW{^B*IHr~dB!x#DiK!eYM8HV$kD_3j$oDaosE6D#SIDm25xbCi!`{Xu|cBlC9#hT zBh+2UI+0ZC0?eaEj(!4VpY&ZtMU4xYt$~1iG7u6ZULZpl2-q-gq+BB1EDi+Z=wG2+ zB7OH_Uv3~EK^O?QqT2Eg`QYDRosYynWcc#~6&uEblz*g~MgNeaA5Zy5`qKU(LGTZk zc45?D14hja7&ZD?IHh0`Qd=Ujjo(mS5P7vO)O_F|N1s7?LHb_8zTCh;f-rD!ClS2B z2Iqxtw8RDE8Lv?;5MhfhAV)ura)I=HNV$Ln!3Es41Q)QuyU<_a0`iP1g=zQ_VT&#x zM?aQwf%NsqzFZcNAh>`#q_AjU0|rK#E>>b68O8w0K9N-GJj|yLa`a;;`=oCj?8_}0 zxck}~p2!C;;&p8#ULd0~KRmHvtWUW_x~X+K^K}$C`gF=A(zh-4<)#l3gyD&Y0YXZ! z0nUuqg-M)2hOrZ6pGaCVdLAS8T zk!}`Kf*d^_YV!La=?k+|NC^^zlsu2(cu1?y;$K8tAM(M!STp~SA*?9aFv2n+_(!@~ zTv3pt2X_SjNMCwIL4x34R}?3%5hwA5^{+F#Paz-X)4T?am8q~j{=$W1IH`0@J^+u#lz@aPZn6Q`RbF^&x5Hp)1WRO|fAM=^4A?Rn#* z8^U-b848C^S_2m|62PXbnN4IE4^uXYq*~Y1JYeML+VM6?$M30tkst(&2dBbf zh7CwKT)Jj-m83BP&v=QlPlVOFTINeSa&&EZ``9wxqwFI=Sjn0}!`2u;K0gLVN?byo zv4C=k2wNNj$kD~{E|HENO4ArXf{+pz7dBl&KJQW=iA%^c!a1@qS%|Pjmyn~2=3OEk z;lx=OmPim>f&*5YE+HRWT7-p@9>gKf*n@J32wQXsIl3s`CDJj8atR57OL*oXthd;J zQJYp-k`AOBr%<+upjubQdj6N34ld{_9zQ1i&ih>lbI|%mPdwhKjjXQRO_0UyMvs{ygQ`d z*OWU*5Zu9&I4VJA?jRo$glAE(N{J8GkZ1g!@`wmq93sf6#Ct^gU7D zr1nt3fy-=#*|`O>jpHaUh`d_Y(|jXBjvhY77Q7&R=TS*Og0L6$APw%M6dU?X=*u2K z6#!zVH+T6B`F@5tHW+Le-vhlt43ib*S4j__@-k@2JN*?|NIsH(225D@1jYZ9)6@M`sI(dFJIf}f!e+W;Zc zc*KS%7$orNR!93=NH{36JfQky7{Jr9Q`UPucU8H?8^;f@Ym!h zHh8~0E&7ELkj$x=%;}(4;u=vNEcX?v<6U(BLoSM zE4Xci(N&YUP1Fsd+$O?mU3ZpMq)({aLS&YQ;O=nQK^}W34RAik>hx3^w(;0YY1qnRZ>3=s zkA0K|IIU#meU*mScw9kgSk7aJe;kh?0pocL8A#zVq~IkULk>pq7?NP%F=XLo9zz<^ zcno=n=CMv`Xv<^0($J2_fl5OM9tXjB508VDhAup=4u|qQ4pADq^SA~a!1A~z9B%SB zRB7nN<625XD<0QY8rtwUOlfGr<8b(Bp2u~RhPphCP#S9SxUSL=#^ZWQLmeL1R~oAD zxPj6Tz~e}zLC52UN`nWF8z~K5JZ`Ks`0%)i(oliNO_hd+Z~+a+rLLLM02j7c++1n6 z!Q&P%G{3<7gOHJdT0!#^bh1!^b?1RT}=s z<90CKc-&rTSjpoKN&}oou|9NE8m92L6O1b!cZTuC<1R|W7#_z#y?ESJY3Re_ZZHOT z+#SXSkK1bOE13y@D9CqbThJQ(uB;~_AoIBXbb zTGQYo>=)Irc*1RCW{W2-ar*VJs`Be668!Ms2#=92z~~}h1~j~2B2+cNQ3ua8evIqo zU=u+PH!(5>*wJ|j{SnkYlp=hN60j=^5`-{}CHyKii3FXNw}~y|HWmGezoV(n zNYHPl!X<<+sX7w^+`25}+(h6^ej_!B1i>UWjCCoKNYH->QsXBgSWF_d8T%J|RkSDCrzo~nCpbyanBPtUA0Fgu@A;?_sH0PK-|psavEp@3F; zhYBd}-h6yp%dTOx49;GXhRC{stQ>E zHsn3!kOYbZX{E2InBpFnCrHa2qyh@Cj2&**=>o6;?=A-<;BusqZdCCIc*~RkINQ4% z1$c_RU_%yw4axnp*R2FxNE&IawOAPmm}eQmE>i_yyH$W2RY(Ew?H+d|ZzzW(P;@J; zbhe5qZZ~eMWuwtD*sr?;1!yH;6TGe*jetv#M!K5{M!;ZGowKA4UP>jAuh$;X>L~w*c%KM8K^G`T50!e>9c*N?KI1*rUGVF37z=;IxI6Af*l0Y#x#jVdO z1k%@(2;m=-D-i2|`~cJP_GtxR!yoU$+hJS)wyO!auBL&mzK_HBN8vE0J8d0NtX{&8 z9^(^TVB6IMTvyXb6V(ubWZyhXYuQewWn{gxoh-mO)yZ`*yfv4A3q~W|K?Ng_9F+&N zmJLSB%uz>FfMZp#lfm$U5pcn1qZZz~ za!3M`^J^*^=~@+%fVa06;0-2aLlQ`myjR7Vo6pO|@C}T_3Y%Z35^%w2q&KQy1k5kg zQ54{96^uY~Kpsr2ZS!Ee!RIY_1z=|(0XGY2U=|L;5lr?dt#DZ0@FZXd{9_1XM}<2PRFzrE1dA7-MhC7Y`d30ao>Sf zI$gCy!2D`By3;NM0xW`%ynm&E&GP;g>(hDv?!#z$yb>s)(Msp3Xar0*8@JH}n5Uu% zz|SP}fCTXQmR$h$h2<@C1d4#P(*0FH0%m~NZ0PMsd;3ftQ z?Clnt`_V>eI?|Wks`Lptdfwlr9JK&!R01w44NS++BBr?)YfmXK-RUDLu<-fdd2e|g znC$`|njH}W?u11neNi<;Ko)>}eh^6Z%DY$G=u$U13cwE6Ex`AVD1l;QM=O0>1r)ct z=(3hQn6wPOFYTfU@DSHx8*Q*0jeyIJM%vk4tXc$;z4O$>nwY0X%ixRME?5EBU|WLW zrAEL7qmgc*f)Pme%!66WW=6}Lrh*BuL1oqth8K*03q~VdsDcqNGR*C|Rsc4n0Dol! zI~fJQH}PF(PAZ2a;6lc2vhwfKCE7QM_*%Xk%VBBmvj4G}0?nNCM_Rj9^0wfZv61AqCKVTL3m>S2-jB zmnDt#HWiY9!EZRZkOIi|+-4~Nex1n;p8~KUCorV$SOP92jr4I9l7Kl}WhsD+M;lTA z{5X^gSpYU9Kd2jMR~<{hbu5kaWfhWuIhSM9c5DIIkOEvwQFf9DFq(i3iJhRIB>@+b zM*6M_NxvLt{4c7Ag(F}dS1A^N4Jm-Wy)VGe zSjC2Xk|FhhBv35jw9+kAOadkyUUaJfw-T^1rGb@spNe%z9*rNKdeI0J8!B4qA{C8* zd0Isipi@PY1~$*5iM3xIjUUf?(Fhc|iCf=yAdoIm;R%?PD!c&rQ4E)?0CLS}k7)te z4(8{=o(KYk2ytr>1kz4DKtr$t=M3st*Lv2SR{OHJSP0yLTW6 z6e7f}MG#2uR3ZqNBa{dMaAtL*K>#hH0Bld(O%Zw#Bj9E@jr2(sl7M&PqyX$}697Nq z;}$Ui`c>YyF{Ga11d2IFEB&*INx=JTxBzTSY2d^8oD=t(YDu}Z9FTy^kw!XvWU-17 zDDFgA%SNIl4+G}G1i<&}-1@~wB)kqK;DXUe`&BRk@&r{rlncOy6yPKtR6C;u&|9ZV z7*cmA0T+@+I!A>hV17%#*+mF}Tpira0p zt!1OpGLNbeBf!3@Px(lR7ma{RkVbl#3PvD%8p0+h!1){zHlzRxRY(E!P54t?NV`2G zP^;Io9;1OPq}gb}d>{XnHiUGirz%Cl=XW|Lmp6o`xHyMqO%q5)<~P`ArI)Cd2$%z@ z+~y{Lq+)XuKvp6i^#3hvnl_tX=Y8 z`@`oQI|A<5(MTUw!3cP__Y1%V6F|1WHa`JmwA%a*D2F8ALefZIR3QnN&vSIxE+vq- zOEYof4C3Zr0oZtZfbXS9pqLEe)(bg-^lhbpfcez$LO}u8qzT|Qkj+@!$5E11fXVAC zAW)1VT50E~Vu>SQKB7jE0Ou000R@<+R-FQ{F?VB3eO*DI$eLEVg^EeQOjpB5fZJ6} z0hXzl1z=-t>0;VhNx;oY8km)TM3d$Y{8yTlbf*iIBH=eBpOz<5$`f;n3uPxJfuc)k zrH84;2*};xd=v@rWtE-)x=Rbdrq{)odLbuJbSbU$R27qexj~H^0q~_BcNnFCCHc4! zYh^xY+RD)g6wzp<=c{N0yo*r*^fi+J`T!Py&5#e^Wf|H7SOE5_n}ECOrhy~+7fepW z4QA;w@&?rhpgDL|d0 z*XGKH3cXwjxWP)Jhrfc&GcXO@U6^a$6DCPt`fH_4$oz^y@dZKqQ7Ru@^pYenDL(>IXV~BtoLo_gk-o>miJy2d6Lv*Jzltkh4HycKm$Iyc=uw4=exG_W{ zou?WiU{VeUJB9>!mVnJwfUQ*b3VNIa!dj)O&aNmDkK3T+Y1}A0BlGBwoxGo;G5v~c-{faJDvq#k0$|lJZa!~ zUXGmPE9s@p)+!)fzd#(?^ZuL9sd`Au-H%^ribN!9wQu;eyVl z$6Tuf6DR}^!SVzPpam1ylwk4Yf@whT8R*~Sn37=n(&b99kfWo69`j8lm_Q+T1zWlZ zElsUdp7y_6{^@K;kWs52To~8{BWVsTx*(DF0?kqkhLTEY`v#>__)Vsp~t9JJDW7HWn<&}LX7vFa{3^P-ziT{DQTiFeMV^#a`X%3^tdl<(lFOi z+DEh83ApcUo*`8Gb$1%L^&gc+AEX_{gL-O78ht7LT92FZLgq7b#YSMva@jfS~i zNh9E-t)_P)yygY|cQ5|SX8bN$Q}o*(`g{o+{Q80belZR|ABXF47#HlZwvUd(^WyN% zarhjj5b8cJ4&y#hjD0~IzAz476o=Qw;Y;H1*W&PHarlZjd}SQIDh}f`5lbEmS`7YH z9L6+=vDd`mv*PgCB^a|}9VV>7MR9o@;Sf#7sEI)UUx(r{Y`(w&U0O%zH{XFHKO+)w zzvwB=O=EMr7GvG5GMohN3$-+&zj0?zNn0hKC`qCtJyA&#CfDNN>(~oqCETu?@ zP08#~k%YKaDU!Ntl_D;AP7#epis*-;4+lR*M@M?Ck|fNgWO^t`V%(x6N!{C&Brdm3 z5{*WZ=!c|^KoTA414@!Gqmm@X%}SEg)snc>J4rN(fi2>^lNJ5^*`ggvBZ+wWq*5fr z=x&yQuig*Nj%FqMKl^IqMwR3FDW9PzN{1pF{(&H+@usqU9E^GIH!n4qr*l& z$2NZNYdbC=?w7>rNZ(SDgc+S~663o{lGN4HjVD(piAHu^Yu7~r?q?}zH2zr%G9Y<& zvZN$g98F1E(&m=Mr=5nUoq*F$qp@}}pnZ=(yEvlSrO|0hdxUDW(_?N>{m#9V z(@w+FPQYoW(O5ef(0)*$T^v#E(&#oydxUDW)06F~?OB-{KBt|Ar=5V)PNT7QGNAqF zK)X1i+NII?N_&KAwbPSbs#xvZl{)P-JnaOWb{dVflL76^1MT97YL`a$QraU_tDPS2 z3h)vDPCE@xI{~MiMq}+{V4sN%U?q?*zNma@cZrf8q0Y@#C3*~Y&2Hn#Exwaa!;??I z$*0j+J{gdYc@@eRUsS%dd$f`tp<4O$c=rl;DdObQ@Z=M4@@X`dPXNaqm|7>i{_UG(7nPoO~LM<&%-G@@4tri^`XFA5!uoR4bnz zvrfrh1Hj3r(dhDmevFKhf@?53(kGPyVKya`!wXf3fkn@CpwxYlb$8EBq-SYKG#W{w zUnG?;!stj}QIdq&l#B}{NsP;tB&qwhl61C~L?ip4%UdxwiNaCIcOMHu}=wFCv!5gEVlNk|%ur;ez0EKYGj$l{~3?gOUgBe%A>w9cca= z!vx$opwW`v%m(&Fe%|Ln^g;F!9LB#7hcVsh6H2!5qvL=c_qhv=?9p924hXn$a1RVO z4rqAefI#EECIh0^P&B^+QW^@x^JkyzOO8g06seRdvl*` z+|cK`JtGcw#k!q7WYEM6_@Q1Y1G>}2tZ7#d;qzO)#fScO^`OUfJB{p@2W+jMzFpHmc}DDwt~(`I=g3RMDMIVNE-#gwIoc@g;RTs_1d4 z&@jJKsSt3fJPrdt*W(1?lip$Vp=>_Tm!ze{$6s$RE7n8EDcOjqJ z`S-vgS*Mq^!MK-VsqGr==oQu}$OOUUf6Ko>o7I?HuQ-Pe>Z zETZ<&Li_BdJ#iAR)lbj1AvAKm+eZIX1{v93jXS8Qf&?z(G5=F|%%#P*R1O4i9es%U zJrKL)qQ|tVV=i^uYQR$|C=RQqI8p{11H)aH-J9Q;81=sec;l+f)c375vOq zMK0k>!$ew4D93IMgx`e6X@ZR~J*HiyB6Vl0R0t$Sr{ZqRyakt+7Xg3wXf)1C>g&7+ zAg|py^d1lMk`|9rc?myyyy!6_R9;edxyp+`kryqO7f#D91Isv$K9~(m0!1pZKglFj z_E1BQ08-(XGlD-3AJ8jV!ZkB)2N*gg-fmgX$o z=?zMl@T0;cl77}s>S|#)9~Iq2W8kwqgmxh%044k(5`)#Ztc33L4y8o+Q6=;kd>zlt zGO4ST;KHR)Lc>!+07q&wc?Q4KA@rpWDj7nK%Am){k2c!baZlF{wHTX0Yj1IbJ?=Y&UBntV|uLjWh2&BB$79(lGrKS4^}SA%3$XHjt) zDl((dC^PySXGTVl89@w~77m!NhRI2*Z>!{l&m$F_{pm3^HDIJ}b5C)kI>2y8iiWqd zBakN$zqv~WwEl}r?KR=xmIgW*Z-=b^gx{1*4R@jR$XD(110i*%D6P0OFSOF|v=Yd* zmcEl<|K6QcITJea^Ev^De~03K7>bt`w@~7R&uggQ#yLHvPj$4^ovXx;DeDzL&RX_U z6#?XQu{`T50`A*0G@$iSo(Rfc?4U1Qq=X6?7bV3H2h1&+G?SE0GK)`C@Ixa-57Y4e z));}jhvR=QO{(bA7XkbUr~cAnBQ5Q(1PiYznH&C{F?!^;g7aY^b&pa#OTe9TaRMna zpwVc4(w`?3-wKiu%uj+?c@CFH>`IwQlgm_QLXJ*OdgQ_NJTs|#y2=bQw@8LYqZ1ze z7$DbhfGjAfqAxv1sSh3J*mfCBT zZXxr|K=Ej&9oh8AeVV*CrS7$=Hwn0Lf;muhEsaK9OFtw&7n4X|dZUskZ)X9Y4KjoGhgIsnqU51Nag+2lBKu;I z^FH*Y&)rSUh?9CfqW!3YJ_uex!T4RnvS7N?9az(z#)KdJ)QKKT{`mt5PgvekvSHJbL7}fbu?^87VEkqQncI%Wm+OO6f7%EAdkI?UHzRW|#xI%Y=rP34z9$NEMw40c3I= zGts})v3)jKq{ZgGVr>zAG!uHv4k{C=t1}_sGMNj*{RL|pP;ns6VR9qBG;rxoCny!d zZ%PhTe|o{5Y3VULDiu<93)Z#w5(v1zU`@kGnh(Pp#RRfb?<&lH|7+#qyBDy#^s^gd zI^4#X1`_)pb}xU$u9O(v=^~Yw@S|TVr^oE15+hJ-ju*o6v=i8rcJalu)8Vw!fc9@w z`&;<0q@C{cD5YKaQSI~?dgr4gxJ>qj;WDAoXbVa|RPrWLvTaEsed)DIqL3*uSjZ*J$CX5>tGA&0XjL>C zsiGgMMnaW&E$lnG)0>qr;YWo@q@_xj)YZcFMPuIdBj9!!H1N%S#wvD!c9%gPRQB^D zz2Tusy3_SarSPNAvC!jo88otA1Gc*i0&bUa5WTolnB6dyeSEfie_yuj(+^R9Lf4i5 zkT_la^~D7*eNCy8icQI2_~C+t7X3ewWSOwItwr zmj-@ipg-2T^dS-M4h(;ntu#34PA9RZ-8u`uDcL&dFF!XykLz6;=42*gdzXOg-ON~& zC4ybMKQaj5IZ$7&-J85gkk!M%vPG3@Tg&&nmkCRJ79)Qh<3;`#14Gd2%0VkJ6OZuOvT>2pQeeB(c zT)NX_Vll#nAC*gwlS{*#qI#ErlY2G{cXpuRX(y1M=i-;(WI*&$6wNEU(zKKYc2J^) zAKm=ZBSR}+R;2E3tZOe+&MC_y(30*$O0gQ-2}qyo_Kdi~C)x=}A2Rp?GvIc!lmXr8 zMJfZ~N9Q0tuG?vtQ_)^NN(i`aKM#i2(**DlmaovJLZ3?|BR=L6Z7TF(E!iwKeCSJm zuksLb^g&{JTpl#cX(|r_E|2qJczF(zmkI&=Ca15^rb3@fB_q~-qD_T9r1Dvwp|?Zm z(&(Z)JzJ$B{OIVS$E89;F1GX0MZl$UAq+1S0{B~4zCxP{eJ+)Z_@Ga;snCbfHPi4{ zHA{KWmp-rZ5OVa%R(f0>G~{+zo(BP!$3-yQ;zYx&Vn51uhwr?fU!Wg7{dF={g$n6T zUsVc)AAO=qBCX^&vA3zD?z^mOS0Vy#PqP+=Q%NIwH`VTU=+9MRCYAeu> zluQWs*b?bWNx-SR42DxlqfuYd50y`CqA%%AYf7c?o074iN{NK?x$8@* zJA-wtN&-&h6*P+e^A0e55Ve-K79vk~(Vfm#qJ$qk!1S2UDp68*z7j>Cc+!WKlXxYK zO-Q5<5+_mOr5vE!aqH-QlZaK|}*ZD-doYE)D>Ar|v8YuLo4=DLU zj-KJ@amy(U^LgfCuVx6i<@8%Z#n%J)rTKNh^(jlXe3PZv+r<-ADtw=BQTsFc4(d9O+5A( za&Ls;$tB?A(!l393|b5id(`QJ+)?P**d-L*=@KPZ_))p^IJq=r3!BR&;N;!}!;?$E z$)$lmq7s!$ALKs66G5bR=}y-wxx$airN_yoArI8#atS!OH^cDc62PaQzCycwq0gm~ z5uf#mw&&?XDlc!M=jl%0P^kz%I_2nbsnC!ozw%TFxK!?e;iWXj7rjrIHc1 zG_gTMA5!6M5HlD~QM%LJSkvy0g&&=w^te=L$df>MDg<0A_rdT|A%Js*uh6DKpGzep zuJ(!csL+R09%m{%my{Mly3@;4D#DMZLXS&@hWQ%W%TpoXQo*uToP20_c@b!Q@*xB3 z$Fg-G|A9RbRYq@>3jx;Q%IxOBl}-UpbrXr*lnxAZlgQhSt%4g&lQ0} ziNX)w@;NSb_fXwNz$si0!zrX;USKb||GWz#`Y~hL<(F1UqmaJz03}h#P06fKqJ+6# zNtC)rD~SZ0#8+T=qfmfl*j47g+dv>V_VzPX`rPM|G?2hv2ItK3G@>tEt`ZP3hi347 zeR>S`XReP46dy|d8CD?2UXIfT1^dOWA?QmlQVN6|y%eIyd`Bsey82RxKyfKV%XR2$ zFuV>WfWPR*$i@EAo>=K~C)SMkgio|5R{HWu_CZ|imBt6%>7P|{!jGO<>2W7k8sBTMQoWnH^R_y-tH zD-BO8fyP?NK<^%GeuI^!G)koQ(MqV0qvr>D%=eT~se6hN`gU0xftK_PQi5?#pBo$* z@kXC$2M2xV>QTI(u`nDTbf*ui41^yYAN08KK|_|Me0&ga8Y~e?L!hs&AoQAoD2g1%!0#5lx7~TLOfYYt7(56D4 zOC=*N@rgDS`jEvbBQWCD3N z$3NdB11cY*%JTOir1pzSrI4fFI-$qhsZ>hc*Hw4o>83&`4NoY6Txk4TCsO51cD8+P zn*fymjLL^f{VUDAt&|Hn`jr!U%w0;k)YV@(=>Vf8ZQIOS`u%!BT9smeq6(MRp*F+W5T`M@Sn4D1>#Z-@}che&)ZlVQiQnG$XZ zrGYb)HsMDfm#4?vqqIrg3s~2#4!vc01RBdD1M-e#*S#5boiwmk$rFB59zEt>B~R*J ztK=blzxN2>o0_BqdlCBFAkK)-`b0a3>BH}>n`vR^(v|*0sTXea_98uQ0Mp3+rm;N* z5^w_;f&4TG;0IZz$I_tBrI8W0@rgDK`miJ1)r<-ApfBBn)$BwRa`fCtkIRFGxu1u` z=0U*aF&&0Cmpe1eIJT|)MbE#y+IX=;*LLXAOk*VGXpahgE|rXUwokOF(1(e#yLl1Gl=7f2y-MXFAFDhFxIA`%;pIU9f0)mgXY-)X<&hEB`$U@ueaPdG*uysTrT?&l$0yMW4$fBW~#vZ65StXkk7^KdquWUCf$xXbC@>3Oz0r z8s;Y|6#_1m1B7ZnRi%NAN>m+vP`SDeHoHQEdVI_@# zlXegcua^bTx9SK4_r~mQU3~ekt?({MxLio{pD)g8~lnAM-@7570?$*(Ack2#;;q@s2>>T_< zZf78UZscafXMLg_x%449`8mfbl$C}D-RVD6a>9?^3!ujh4;tBDueWDi0&aNV`%eB3 zhY-m3Xk!<~emF#`=&v;pfbcm@7#HOqgqG%p4;1rF$k87Tp+_#V@^K+`^$&*-a6cS! z7!27GpOQ!+V^QgM~x2Wh#Cn(iI#y|?bvUi4<~7BpvecYA%vMA@V3#-jBx+Xgmg_iXH<5Ae1u- zKQFo+u0e}Oo}{_CN~n;dV}Ks>b2Tlct{wvf+!#0-hS$9Wus3C_U<*&5n}`|lRG(-k zB7Ml^3CM`u8lpSBP^BaM=vkc}HxX$_qxnXQfSZWRVR)$!z~0nXXx9|_Tq+syai3^Y zp%1A%$c@$?!UdD=^c9tg@S~~F<5Hnve!;_J*AxOSl_41JehUpRF9P}CieICW0nuM# z|Nku%Ee*V-L<>K9Lz*7*q#90Aw{;5)4||Qe0t}~>hNqQ4W36OB>z}CghES_C(8+jq zyCMAO8HpbGR#-ksrS24^^>i?tRvMmG0*$qj0j<|?FwB79(lnI@woqDyAAJ&l9=WxV zYn8flmDV%Ba9U}2S_w4PN(Qv9rq*{utGF@Pra*ER+m%>HxP-k#A{B z1Iv_F;YSAmJ@SR=d;mz@)k^DGU^uNbJgo#8Yb66(r&8;C!vP=-oTs!3Ke`CeBcJW& zTBYt~O6%ERIIT21tppltB?DS7q1H#jML-(3R%sP}^fxEzF~3n`KSc}bq``)d*)qRmPeo^J;LuzyWyeFb$dpIojd$m={!sOWlWA z*LL{Vz;J_uh9{IjW1(a~=;5)a2&MLuN~n;drw)4L!MS`nmbxz~p;wl*5x^IBNC_q+ zeQsoA#Qs5#Xh#Np7~5xaNAbIGk)}J{jy3Is6n=DY(BlRN4Vf_c;2_`z$5k*~pVRRA zoIv9~Cj+9dpy=O(qNRaFO0@8!*>5)$WbFEVMM5XmwFq~Ezo>l^lwUPm?U!v9zh6|lEaEj6@{HRuXoqF^kgV_)t+aJ-LzM(P@est>5s)S12jxCD; z@M|!fP#T_40*!@|0in&j@G3t=B(*0nm|ZD^92H8B`KuBtb*C$#&w}BE((r^5Xe^Wr z?DO`EJ%Ay#XDgvX=C2b5PrcJ4ztodYDXBYO34IZa?2{h<$$R4NH`!_AdgFf%fDG@? z0T4h>AI{d*vi@T{DgdhEL0Q8u@sm_+V`p*FnaGw&5YoA)F+`9n(eR$!(8lHJN z+v|Ar0B4|D{jBUvG#@Y3I;+(eXoS7vBRsG^!ZGP1oK8M+TY%geAY6p~T0Fz}2v46r z!p(w@aI51Z+^G2ox0yb2Wq^DwKrRW8wE=QLfSey7yx8}n^FD=-oE;!%1<0BJSsfr} z1PJen`muOV*GGl|WO;xb9Uw;q$kG5gBtVt~$N>Q|H$Zj>knI9wPJqk^km&(3EkLFO zNN<4D0;D5A+5)6CK!yj%umIu1#{Ti*lhi)Kr^0=NkG=Z{pV;>ie%HW9_$>+_;a5a_ zgx|vPk!J#gUw863_*AZh;BkQxg2yyU2*2Iux5Muy`Ut;L=_7a|u!P_d>k@+RGL(=T z1LTGPxi&zq4v?z?Hs+- zKvo3EP=Fj1Ao~W$J^`|KfGiG>MFBE5K;{IsgD?r{3 zkT(M4^#I`?vGQZR8X$iTkXHiaQbAa3wAb6g#6n%AooDm?W2gr&5!2=zomiG#fy#oX{AxgDy52=LgA0P(= z2)@lwsa%_McA0S5rdx^sWWGJXLD&Q;(X5|e*t>po7 zYJe;YkTF5a2L;hz2{`iuq&cW{Vi2odAn8HHrPsJ7a~v+*&6jXdTz)~L*Gsh`6M zQ>hML!A3SkI#);)wx7jqk+`1@;KHkpq%3>6nhTao<&O$%B+qBEqyG;31^k#QBUx2ocjrQ_08acNeE;-nyMx5WKy5VvOI4pVW-(s604xHPLnaZ(VsN8;iHSjxB8 z#vQKWlBMI)R&i-ohvK9lZlAt;x&J5w;B&ImDG-p6KIF~67EzQ|NI5?GAPQG@{B#!e)3;XKJ zI0`sNlcoELc1!)D{5aCw6zMDF<2WdBaSkfQon__=g^EKhbG8%CB_4;C=4>yVuR2aXW_BQsF*8<;8M5@Tqpija&FWB`6pWc2 zCGOW;T+T0ATH9RVT7s%l@aO`(&YTzV2~o zY0j>~xys|v(ws%Y`G&`#r8(~t&ea}=mgX!L&NUu~mgc-)IM;d{TAH()aK7nrXlc#| zg!3(rLrZgZ7tXgm4lT|3pm479IJ7ip58+(zacF7Ip2E4oY${oPC7zJ&!|6b3P)Rn>`LK&DmEtw|E>{nzNs9ZuK~{ zG-rR|eBa~H(wvV9=QhX5*MS3wV;z{v`8Yf~hmxh|BW-mqqgfq_lP)NqLl2a=x4XEU zkF>P5gM@R3$DyS;2Mgy19*36ZED_F~9*36Zd`viZc^q1rbBJ*6_BgaO=i|cpq2uKJ zxs*8ivrY9US-L-ItNx@}9g35J{ybFT-s9r3KWS-ghY9Ci$H}!FZnf>Cw2`H?(N@}M zR)^xGK-&=#_r4(Rkv49Jic6M`OIyXISsjX#g1ARX-1}Wz_6aTBC!Y|`10IK#<{T}Y zA9);FnsbbB9(0_%Z;vI8<32^@NS4l#w#t!abtp~>ay(Ar{y2zxyp20U#U)F}rLE%9 ztPaIVLEIB0?n5pv`<9mOlM{vW6OThnb50V@!ybp0=G2ArQ;$PSbN)v-k9Ztfnsc&n z9`!i1G$$3#V;+Z=<}4G=&pZw-&H1Eo9``u3G-tVRe(rH-Y0jsF^MuEtr8%bv=NBG_ zmgam~I8S;UTAFjJaDM4=Xlc%A!ugfQp`|%P!g0(bC$!CY(1NC)akV)izCOBTH+et+dgs4#i1c^TIJ7ipopAo;acF7ImBM-3MNSn zp*Sh%t8Yl$|G2p9D_UCH)xvqladK_fSZ(8#HnOxf+Uh9a@_6J>j%CPTp5H6UX?UpvD+ky02)f@lUfl6ek7a{}zdh zXV;WAT3Xw!!WrRlXlc&(h12FZx&GU%{^?3TSz14BrJrVXC{7CW-!5_6U0lu)T3Xv3 z!od@JDo0wH^8?|GbevrOomPK0_2Y!Z&j`rU`f0b+aVEm>M|hf>BH^^;&yl+%E}kz` z+GuHQcME5<$DyS;KNJq098&Gj(wuvQGuGqK(wuvRgC`(WJG3IJ7k9e&KX^ z99o+5fN;h;PTuD~B91ZNqs9zby3c8=b(LmyC{7C2)dwXmp8K>p=5c>)@2tldtNS($dG`r^3PC)KDB+ zn)8To@Jy}Z(9)boh12J8Xlc%4!s+)ov^3{u!kOrCXlc&l!ogF&N)Ii~`MGc=J5GMA zpCFDg_8!&eWa&Pqt=1)))uA{kSeJewaT6Dp>k=)k?MdMnk3&myekq(O9*36Z{7N`e zJq|6+c}h6bJPs|*`L%F1^Ek9L=V{^Kp*h>}&IC!d?R&X;3{zkKRGqajNl z7TW6A(af3(Nx`whJp#ntHi(P+0upx=KFe_W8J{fVkVaxEwRI zbf4g!0yx`y99o+5x^Q;zIJ7hew*}A+eiB(7M_QWmhH&OOPTv1-635y&S@l0zIz`&5 z|7li-;-sMeacvK6JGr>*2U=R&KZUci$DyS;xVA?-_)RaBBQ4FrwLLiVJPs|*!L>a& zyLcR0nuE)8aOOKs-dDKxmcH6t^%YsVuV|~jqM0=nl7ha%r8nX(2;$KFe;^LYdaTmI{JVvy1pWw0@oLxN*EzPM6BWIDvp`|&)g!4X+LrZh2!ddKb zXlc%H;k@7D(9)bH;q2ydXlYKfa6aI1XlYK1aCY}Nv^1wxI3M&lv@~agaQ5&xv^1wp zID2{=TAI@?oV`2_EzRi=&WAh>EzKDzoV`5`EzKDvoDX{(TADLjIQw`UTADLPI3Mvi zv@~a|aQ5{$v^1wvIQw}VTADLXIQx4XTAI@(oR4}OTADLnI0raRz79+vjx}>LH6O{+ zQ;oKok2I@8aZ)fJyCv>{LEM^+o2a;C>A192T$J?RHAJ_X(LOArLDBltPaIVfi_%^ zp-&DC;^G=i;?7fX$7uRoydzg#MKB1-i1eajo9PV*wX$~%zz&XO> z(9#@S+JJMU$DyS;xC{a3D96eB9~TSK5A#(&kfl?kt@?px)>KFe`T^Gxi2I2kF0LOW z?iP$|_o!s)CTXiZD$T5^kQD4uaqWS)N4vP}e_FavaP0xkF&>AO=HS``oMSx>EzQBT z2RO%h99o)#YY%Xa_c*jP2iG3poZxY2X%4PEz&X+5(9#@SM1XUW$DyS;*zki>_c*jP z2YY&O{>O3hF@t@)9J?*mm?29a7TRje(9D_&Nx_)eLE@eq#NE-xovq@MrJJO!;?k@R z#YsV2Z2OUK8pOq(Uh>^a#U)F}rLE%9%$f>GL0nu9Anvjt?t5+AtyNsIbd$7IT$))^ zAt{JEPvU;k#pN8KrN;oSAE0fy$DyS;^M&&%k3&my76|7Qk3&my77FLn9*36Z>?)j7 z9VZ`?i-=?2GE4OpS-Kl&tG=RH9g35JzIva;JuQg4*v8#K#U)F}rLE%9tPaIVLEQIC z+@T=uZZ__qic6M`OIyXIiLd@eNkQBXNZikW?0>&?52rJq|6+`G|1VcpO@qv#)SI=W%Fh&VIr<%j3|}oc)FKd5=R&b3Q7Z zvpo(i%{f3gU+_4zH0MC!oZ~q8ygrCH=JjHZH@i;0p*Sg+FW6^eeLg>ki|w(* zU8LfYrQ_08acO2vg`^-ZHp7VfB^Q_dMoaez_PgL*;Bjba4)(j?{IBEW{f0fR=zpKm zPnMQOTj{5nH5HNq{n#HP?u9{IY;Gm)dsSSrbd$7IT$))^At{K9O)TPm*~MkQ(b9c_ zeJVH?c^q1rgMBJEU-3A!Gza@saMpSpTAG7>DmWK=99o)lyl^h@IJ7he`&6{^RmaJX zBlf1!pL11zlBK(fw(3usSyLe?=+BcR?$=yg_9rc^tuCBPJq|6+!3GujFY`FGGzZ&A za4z>av@|Cb&J`YqmgX!I&N`1nOLMRfL#!)34lT{WJ`9|%dmLJtgMAn{S9u&-nuC29 zIN$I%v@{3%FmSH+IJ7heTPbj^@i??J=QQD5>p1y1!L~%k$s9FK$kIcAwi+iit3z>8 zFix=jfVOYCxEv?6v^MNB!1*U##NI-3+)?F7md=s3 z%8_Q)R7eVP#J&V^uXk~oBQ32B`x0<&@Hn(I2m2CmzT`LK z&A~nfoLf8&EzLPcIJbHnTAG7B2ip0*$DyS;*mHn$o8#pDiLHY4=K|HAWa+M=t@@K@ z)>KFe`V$)i#JxR;`z0H9p^8hEZj!c&OEYUKBn5G?S3ul5g19)*OTN3RxMb-jX{)$2 zv!+5)5EmzO#QlMb%ke`?9}Aqb!MW4p(9#^7v%$H`(Oi99o)#^D8(HcpO@qgYzpmKk_)V zGzaHba31tHv@{3jS8#spacF4{&adD+Jo*?5tFWevy;W^ zx8nzzx<+)4nAMkIJu3)SC!IH|QW>^lbJQ8M9%1)bcFVG_fp%J@^4yfHUQOz?N>d{< zXrPy&D!=XNYOM_KYU^xU+ykz>}suc zuXqZ2S}qwoVnsZpd}+=)TBl-ig@#ijf6+@ zebb5!d_M*?ld(%~Sv3W<2h&P24&9SA+67uqR(m{aw6DO=el-n#sFI)y(eB?-zq0yHLj8MqYPl5FT|PG-PWpUa;a zy9^M!ZZ4j@s3Zejtv$8#z#Z1r)Y;UXj63gRct5JGd*E{L2Cl$=U$3;)(q;GwJG|)` zKCmu>defl{>KonKeeuAR8QPzt6Gyk!96BjSCy#FJacI((!%6$-*4_f|aQMj4t$hVP z%Hg9&xAqtK7>AE-9>B4s;-oV@J<~UEl^~r>1Nce;#z-;~T`{`lgn_GJ-oD};9;rb> zZ7Z5^43b&wsZ;Pnb}M=K>nSTGTLNrev7X$ma1h&**#L$(WLqvC-P&@o{P>s*$eGF3 z&PC6&|>z{|kN&rBYeH|1dlT(K6W7*-|^OyQ^jK zE;#=Dcffx(ZhRW$5AST;I2MH%U;9vuEi>`DEy_ZaJy8xsIT9sBS#Hbec>My(S5Pjo zX~DqTFZ8qj>!V%CBsB0k72YGRogjM!dUmjLz z+1Ae1Su=aPTI_TkIYLd*bT!8M0KT$Q#zNEZ6=OMqJMngO%Ze_( z9|z6tNf(eI+ASBIR6A}%lQcal8SmiQS*S}(Ze(qsxkw$`5NXw5=CpG;+y))k{cS&!%WDxJ-kfz6zO&5JjK&3|WLbbkTm za+IIg@&sO=MfpFJH&8a%G7aN%9?Idi9EsOD3TMC>C>Nt#ZOh$weZ-dE;`J{m@1Ts_ zxN+k|lmV2jP~s8I zfwBI56psIOc;)zCgL!a6wufk{G(kc0VxGQPI#JF*`7r8!9`qeA#eZ1P_C%E(@zax) z%H%F={@=zD+dUO6E^O|;_~3OI)lGOaa1+Md3DdrM3IBa-K88~ZrfUtS^}I@rtnY#K z^zrL(T5rP0e2WYHD7h0n*$eH5f|HL`!J4k zU+!Y_3l3bj3!Ra~o<@x0;zCQn89M#$Ik8Zks z#TZW9tx4v)le)ROusb_&l5WBVQ2cY8-|$?>#f6+PI9)eY1rpw%so?bMI%_W8W}P*N zrGNc*rC)aesCHd!W{%yHjZ7AFHQBYiqgAiv4{@c;*78=nXIXz3nrj;z-iCE!)Z#_# zKm7X{PTHLA|HLb8zP^J}#fg)p8-*wBJ#6_XUJpY#0fi@SmK7+UM_G$<4a!X@KSg=g zmN)U*jHQQV3d+v5EW|6zo+t;P9FB4d%DE_4qkP|%U*h%mwhV*TDYk5d*F`8FvgK&J ze#(|p@yc>0%K0e&YYTI|1m!y@-$!{7<##C0?cCWkYDBhR4IAOstHce>L-@2u8S5Kvadj`DbsU>sHnNI3+LBm zH)A!ath@#P58yj~?E|>jXkSH7Z&$5aKc1UQTIZgCS_8Minf=YJe7ioOpS0PaRfqn{ zRc*tt`t4xhG6gu#<#P50yppGLj^pamuAa`GSz{(S#vQDHMX=^L!-TRqmOiwy1g+HS z7)o-|w?MicV=vQ!<*yc;470M%9y!-5F@-?)KI(7VHPPD^F|wlyqV=%|%gPMW&EIzH{(s`5YfQl_J` zqkG^$(|QGD1(bDxK^vxGVTE1O#ydsZUq-9wVn)~#diWvtzd1d^=9za zd?#>6C7Hv33{$~XMGfoL#xWJSEUn=B!6k0+!5?#j9iZ(sb#0b*uNcKd-d5U}I zOf-7?DmGsk>`gwxM)q~t@5guIOFoLXqml#QuMY7jcTMb^C`XjL7JSjDG8+MR`~d!| zBufxyh?n);(`FJol8;GnqRGddzbE&PO_l=e%Wg}Y$3_mLl*7s7%>dof5z-RT<&X^$NDg8T82(D=qfog zx*0NSRPssdsQu=aQOT#+8Ycy!>6wJn>M32dwv`;VeNP_>=BbX^=QG=r)4)u|lJprz z>M4^}khFlL(;aEDPa11hK{9O~9I>+>8BY5CWOlT7O?Cq1zG5P(Ij%+VtE|5TS zLqaCnfcf7H;e87nM*LeKZ#3R`R;{Bn(^JGGXt`H(wJ{4}#&2 z82eAI*}5;tUTYUjKK!ZdZO;YC*!+F(1xe50PyL{4M8)7{7-}Vha-Q!R-#NZJ8GC8x z_*xDB^(33)|K7ylf84+1LXeG;Ljm-+;lGL1A>I%?Dcesjy#>&u44QnT1}A4=GS)+r zwr*5N+B=(BG3n?Wu|_qNjO-jS`A82L)j0x9c+hA-Jw7xBkny3hfChZ16VTQ^G!D>? zKGc=n;KG)_{nyhL9ejLtbM21FM`)qr<0MU)kWp|o(V(5~I7zpIw^{mYGaC zUO~Il&D^hI^J8!ajjkTKx;D7%5h5?Z^XcAYaI1=FcXkDSIIH276rhT^UR9WA&#R*i z?mn?Xzg);0+=g-dOyNF1FliJ_36WVDP|`_1inv-N*tzjr3`c{oa_U2F->Q1^&XD&|pn z{V(e9R1VbrJZm*q$5A_%$;n>{N8jc$PMEgE$Iie19|M2Gh5w2^o~wT$HF3w#JSp$6 zt!y{H%$l?Jg&tnusvkV<_Q`AhywB}loPV%m>7>t@XUTqMygIpI;CwA~2JMj(#!5z|9mZ z94EWq2?Kq@8yjazyvpEa74rwdIa^DjrogMElGc8%Pp50-n{Ip zwImZev#lOZW9F|Go7CB4*LtF_S#)w|v*bzaZx%~Bn-%kQK~;`CU`~IN`MdbLJIou| zn~~;Cc~g=7qMLObzAU&RtYERK49=^Vf8n*O*56^?mN(ra2L~$V9eF>o!@MhRY9j}` zDstt4S>0iVVW8p4YGlO>mv_}x3~t_t9&yp9j?YK0X%b(y->~~iIkv}`X7O}3pD+!r zSOk`cJI z=c$oqioA6X5MFVPF`MPseOQ|-W^*yKJzcgW zX18VPSb5sbA8{h$jTg@B9y253%558QF%H_;!f(T}XKMD(Tk)sOGxjXO?e%0|abn@{ zUWnp``2335I%^|aOYnEpnmF#~Sdb%pg@73M+gq>==co+CxW}i#817YrC#N#7Vs;iN z?~-iAdauP=x<}L>kc@W8D%Ov{7NRQu%SHkxjO?Dy_^xpkvoIrNAF9hAftN-47dW|8 zhn~X!_1Ab;XZ?vdWp;MsGm&n7Cepq5eW=HOm%Y4k<2O-$it~K55Gr@p=Wy11Jxo{1oL`l;5JfhVpM)nqS$tu?wZwmOb$Lag^mKUqQJZ-%j@PYG=GemeyP)ia@*$KHP(F>a8s$us zFQQz5@?DhsQ0_;02IVc3>Yq1m>_piPWr{6)zdg#1DDzO3pnSrXqw#tg$`Hy5l+U7^ zi}DqewJ4XNwEq=-gjeRn*QZflvgKcR9sU=5@`^GFWh%;+w(N@6y-@Z>*$?Gdluz1n zHeSDM%SCwo3d*In+=|!xZCQ`kzu40HDsr=B7GAfvWgomAX3J{4US`W(czx2AKjHON zTi(GdbLv2uhH|bgm*e#glpovjOT0dZGWIoml8iDDWg*HQD63G;;QPOC+;{}a7g4@$ z%k_BuKFYl)&!W77vJqv}8yh!{L+L}=8f6z-_QUJpww#RDvrsOuW!XQ`4&Jlx`MMtE zpD4rM+_*78+1i%(;B_aIkE1L_Im(umcs&>829%$n{2b+Jly^|xMH&8&tW3n~Je1u~ zK7#UDl#5ZWLHQ=icTs+d@>>*Y;p=lKe?WN?r5ieTMA;K%FO(14axh+xL17-BL|KmV zDU>r&E=Ktd%Ka!$qx=hH*jqR@D0P%MD2&C|_o6ID`G76^;PqgXLu~m3URmdVP|iiU z2IYQ~U!pvR@&d{qQ8u8A{8!d4Uq_>KqilvU9pybJ???F<%1J1zP`-+CJ<1PIeuVNE z%I{F#LTP^+^9*Gc%KK6FM>!Vd)3$sAuXow<3%vfxmZSfTxG2nzuLCH9w#>up0$VNP;N%K59L`Dd?s7#>h7G7eB=nz&SAHft8Rw-tv(GqiN8vo2?uNCubXV)R_-gq&uKlV! zb@E+LwSH~(uD4ppWgoG=YW=G0U4ONHW%h1jwSGnRZc>#GB9S+_TF2cPzDwGw^-JvA z_G%rsg#_)W^3Mdx+mY2e?kLIIQPn!`M9JIH)jIBe$=fm2I&PHm?W(D`2h`IwB0FK% zvd>TOp}akT|A=R@KA5!?{4k&&H>7yzRvFZq2sjzrvkcj{H&D|J^ymh9bOSxQ zfgasJk8Yq>H_)pa=+zDM>IQms1AV%IKHWf{ZlF&$(5D;d*A4XR2Ksda{knmE-M~cM zz(n1^MBTtd-M~aNuwO&f+r-+5bNO~TWP z$@t6LYW%N<|Ml{}?2#fo>IfD;oz0$a9CK-BQ;qj-n|hK?{NJ05!~ZMz1P`8l;&Q+n zZg>o2M0KJ(m&zwmDEMy+*Ws}pyjidSZ+fQUfs$SDrdQTxAIP3`t>A-3_!xCW zRc?7_kKy6N(-GC4T((>%Q2BeHmyZbLp8(??K-Y+L5O?j9u>%ibyr=Wq?!p)S z*I-e#FtTIDdBY0a!f2z>jLO`qlqdpHriPr@89$aaTC3j|SwD3>hlkZ+xUb1m2Uj3Fw<+v8i>QFOh;ZKo0{*-WAb*L3)`(O_}Ey{z3b4SqAf@9iRxn*>v^26+yvN}S_%kZr0 zHX(gf+pMHo=U;fP)*nZo^NxIbe;v0*+w1$W_Xnp}0{gHAWUR0aBbWTq$P-k~b==*I%h<%I&16jfFEUF0sEpl< z4#1}-ZiH0pbkrZkAyMd|)jDMdFyvr7u`&+kDVu7Mecia~J*pdqn+lG>an<^3s8+2% zi-V2NYF-5cgX(!X^u(mW`f)OJPz6I3Ri=Pdt>3`b@+$Bd@l6xomfBax4RY{_>E`O| zB}xGwD^cpROYCgi)(7J-$F{WEUWJCSqG7sFC*glg^jGnMlw6p0|2W)`*Y}SDD>v@U zE!e!BREUhdIC|zn>C6Loi1Nt8`+#37_-*WDhbIP(^ThF(R{@Pxn&4ZD2xyXV@@^I@ zOV>|>Ei~5qK%v*KN>z=ko<(^!)w-ighhq>y>Fbh3T`OgmROwqGK78A;$b!BR^xY>u zeDA>XVO4_foUESLWvDlnzVoGLPW9qV27a^Dd5pO2=HX_$^ zH?RPX9mH`g9eFR*X^DbTeyrX&zbCRuYqE`dR6!~O1+bP-zqc;-}&NuoNc4it?B>=!JF+mZGYRgo=U08!=|9^*!kFQd#Dp@{h`GgLel3y zZ^N;_4zQ>&vTRrVw`>;|HL&Y}p%asA$&9VmZeKj(XPij8-3dHM;GQe{Wt`oEIQw6QcixwQNU(=f(D&1o71&}++EiP0dvKFyNMT20ul7|b+ugSzZVI@A@_V1ky*gprC+$%0@T+BnECQRlAe!XRaW4pPm6 zaI>4;k+Ju5q{s3Tv*j3avfDa$GiHplfSj8}QNZCniPp;bI7&E&;`+B~6H6~{DBy%x z8QrYr0qz}qVl=-Qi6O96^Z0bWd;VTNByidHNC$qs(vm-eKe%P30lhb%A65DP3DXzU zYZ#_hrvE?o-aJ04B8wkA)qT@j)=r0Pgrvh7NZ7Z4EI~k)aRE^XYeI+y0STLk0z*(# zR8&wLal{ym3nD5i3Mgt&R8&TAWEV9kDj<%isGz9td(J(bbXdlj-+TYO_l6JWn{(=W zYQ1%8^X7T9_&^*RUnD&=C6_*DCi<;oqG`z}L zNd62@ezT^Z9TfmRk+ENIvdppc zx*9t9G@6$_mJXM(g=43jM#nNeyC!z(X>=UZhoyBncKy?6UPf6OEA&@qp?PU#=~&5| z>9o^g^K#45aW!;<(`a6PS^5+gE%dwPn9a}F6L~h*zYwi%JMi+%Qp__$`qe0D9U3tgWnVa$dw)ioP34KMCs+IsK%wr_W0}OAknCIsK$%cKVg)OkX-KKaEBC zGx+Ty7b|m+>ExTtj64O{#iV^`yqCno)OJ1_HxuJFgGm-jvrV>!tIto<8g( z5}rdwjI7tegoA0Vk;2263+Y;f8(1@~BbWF|B!Dn1TG)x~T=o!tuVg!|dzeGYv;lT( zEKAsNhUX<=p7leXSe~-G)>He{=rGR))2_DDOm}JVJLKh`SvJhyunSk~bk1UC_(Hj7 zL~23L5i7jN8BsN{qP5Vc$2v>#vntVcrS=iPN^lBQ;#kjoUr6te$BVpsjK{k}Ss)&E zkgrAE9kV~>gParkX|;a`>?C>Vc$oWKxNBzZ>M#vL$2YY2NOsteUur(sp_<_c`*{>x zQil#dtV}1@rNfUU(;F!H1l}xldRrnP|NA_3|7Nt`t zz>bo1W|YqCF%su>C>LHTF9CLxw68&Dd8s&epF(dCr$itA` zkYkWPAcPrq8IT^3iy-46H$onUY=Trn{(z)o23>c^D9CKcD#%9=o>6xm}Uu8}c0FFeHfg>%$-qLtcVxgT&xndm3ahmi@1Vd=B{y zayQ<+S3=%|?1G$tcyX@qyZCO9F%aH`WC?_q>%R&)0y)Rh{M}6bpDoP~pR@KbuJzYJ zqR`Tn_{)2d4M-z;ov;6s0;!3(_)kr-mqA9S1X6<^M-a(mkjPXf_;e0L)rVss2Cq&t zapJ_sgmx`st7g|S%tz;4%Q#GTEla&)8e-3FfDqobtj3#nEo1N6UCSEUti5ZQKSo$= zTgEX$+m@wq5n@q2M`J&NREKwN6x=X-1`*wf-UX!}B63q~On}sTB6V-=2%&o;)T_xD>xg`s zabh6VjU}VO-;FzYNpLm#q}&)5gfd^5g3Qqi-HBLZDwI2ENm7_kBz?R9KDjp`DzMo;1S7-5ftREOJJdIG-}*a2ok5+BCi z9H-`>Xq-L>Oqt7}8GY?IKiP3^k~sZ2PR+5=I0GaOhhkR)$>(P~&R~giQB9n5-adfK z9+h!10yDgGCDI^vNJKxELsNjqcK9!Tkr{)*CC+6M`y8Y?9Paw1KO%8=hIh&2j9^jW zTwb-2aT%w;8lF|)=+->SkVKkfT+T6V9@{6Zor_2A7IsKL9M+O{t@ma3$jIj|G8}=W zKZZ5@2oCr;EMO!DoD2&Xg>Hm%dki`k7pg2Buh6kOLTa65->6XS%5VF$3uIsgxE+`@ zVb^-u5DgnBAaz{vy6o6tOZM%jG8yC8VQ-B?unb4Crn>4=3?GL(_&8dk^anK7g1Jdt z;VU@m0lB(hJ8KtrJ$cZCEf_$xt)Y_j7}zteWUgL;rd`6G?Q1+!YdrZLzmDg4_Uv8b znO@_Gfv>LTRqWZf#xo=C+^!SgY9C3*Y_7yh8Cjt|FcGa;pC^Uk^5l;{=3!}qyZe24Q`9aDh11jKwK36u%qfpC#mn!<;OKdEs1s z2x;$cflCK>5KkuI;Kv&!KI3(C=^0#T$CJC!M8v+h^f)?ac@U39B|V$KLo<7;J->U| z2s~;!(0AlqzJ1sIFlv7q?Bd*Q?~8%9>5e|_&bV|**6x~9EqF($sKEzA=jU8rb7t?J zfk^zM)Lw>m`ft0vkw)kQ2-`Fc9|~LwFZ1u)RG-s^2G>YTgBb2L1*) z{elmMCwhA3_7)kb{wQqEz!RVCPJl%w=cA{!i!;Hj@ev7`;pe|p(ixc9$>BZ$#gFFQ3`I*cwD$pS}%o#{YPnK_al4j z0ThaVvO@{IstIvectVe!t57J=COeKh_$bc=sipi_PIt+}em*2mH>SN%x81UX z_ErbzY+J%2PJ0<{I_AEs;g_J=_D;&2(Lj4c12j>|Su@heTQ%|(HBS1dJM39Y5Kks$ zRCJ#{bm4)c3>>B3Vf57f5K-S|jrmeJDh-iQC#R6>qFwkP1XoH!q5e}(ShcVnklKL!@wHx@T)rTdWB zN0awV3WX#|NXSxt=A@D6MVN~!=^T=D68)B}m9lqUz%N$)-;u1H2fyaPottG3di8>s zD;rhZ>?ZZ`y>T<1u9`c=*!LF*`6FRit z+Xc2}PQ>m4c&#S~(J4L0G25X%2t5xIv~4SiCrM+Ir4jj|kmOKEcwkCcV0d_H-EgKV z?AAk&euM@L{$vN0@|&wk+2DcOkC+)N2@%U`-seyQI ziLY&vkLJ=g@o2cTNm#g7!=+8a!hISpZ4wq9so~NlVc}64E^QJPj)%*&Z4wq9qv6sf zwc)6VUl_Y>T=qsD(*FZ?3^_?A_+67__JDMTuekvdgg*TqSni&3gLoImrI6QZxF&aJ z^u$272j|fGn$N^~p$%PDoWKSS_ z7Y`iZ2tL3VB(>4AFQH(DowK||45vEi795DhFABq{6bd%cSU5++Dayq#Pr)oZfwDWTYNqlLJz{^Zl?!t0G<%=e|$v*md~YN z`CJMwpG)a`KAibq+`&Kos0Rr`T0y!%HbU~gz(x;{t&nQSmnz@mulq}E?f}VB>4?91 zkU@}%kTS?akVjSCz~6Tu??XO>`~W!#`4vLgoFfQn3dw@Bgj@s}0sS`L#iM;f*pHL;69kgiL|l1$hkeGGsgC zAjE+UF)TZoUkYr_vaIheC#{T#dgRrvkD9@&aTRxeC zQmirue^)@>Qu!2r{{{IK62K-L*^rKqD zAx$AKKrV!En*6sI!W&|+%!AyZ@^}1wP=({X2w4YN58>@Esv)04u)H@Fn>QzimiH!O z-nsqneP(Ny_a@8o-V|JN{<}>wQfim?Qmov`aAAMa%0nmNgy46*R}ypa>)gTNvP*e`1>OqPCxGvsrP{8ybwM_-OG<;41eA!ry(zX zw@Tp3w;RCzXZRdYk9Tkf_A%cahA)^8b*~Y)A{Ym`8ge`2VaR649>~us{K*i0NgseT zf#g62LauPxAC_=*3k1Kw#{MZi9N>`XQ#`DsgSPHO}HGT1fNV{9LG04 zwHI8UOs$!t;YKR_uM&lQ67mA%HOMB&PRKdtF0jl0;oJoi$LGGG>+hnd*~mH2#-arL zeUt0rv=%IJa?jtjPVQ}GZ8;u)gMaHRJY4yGs%%%hUVYoZ_wA7Hq3j5{9)W+cl(q*sNMU1Tt<_E~3;JDi0}msq~zp!^|Gq@Y|3bgF#Wm$?o{mWl`I;A z{*0$dE_-Wme7FD|0y)+3%<$P0aPUYmF|?^TrZ#3(AX&t9Cr>+RKd^FRw`J`!@+>6_ zzYOA$I_(ej!2B26!+uy(LoljG;`hfJx{mVJTt_uzwsus<$5gOQ3U5dA z@2;bK;nz{P&Os}Q1TCV@5FXbv@wa{(FFl0Y+jn^kN(#hh43@T2TN3NvO&(P|rfp}|jDu2W$;1A?r-p4Q`&;V}EH2VRvFP)84F`_Ws#Cz=1Ox?5K zjw_aUe8eF-5byHh!(uVmyV9GqE82^0jBVcAeu+zy_$2;fnP!fCv=SwAT!7Sd{RkH! z@i^--u1DaEx7A2og~TV~oT?XyuNQFPRF6-x76c-rbIZ^YIMd^u-Uhpt;0gd0#a^vt zh+YtI<9Y*DMr;8twNOiRwclkwY!qD1RSXL8vO^6I3wThRQ zJ@+nE~!=l)51tBcy7-8~Yg4q%JOa z3{xP9)W_g*)}s~avGsd6MBK}H8aEDIDvmO`I*xLW89Xeul#bAfJA!<8&Y{iHI+QjJy-n@Y z_G^1u4|pAKL*m1SRveiwg*eWkiEVM1CoDVkFE!w zZsDpV?UO5EDPR|VVT8F(@kutZAb{_d<*w$yE_KsQx5wcae@x9d9Fv6c>!3Z%#w3S^ z$e0v-EHe~ZGx)|}@a40Qv*#Bm+%;;vY6jpK48S3;q|?1ZBW$QrUD1Bnj%ych&E=1l zBhe3I3}Mn02oDGhvi6DC!+^->j%wPYFMrhnqi<|z^c~HkuOFkYpGRMR-#jz`|Ko|R zZ$fx->jB6y$WJOxOmvNfWI&pzWaDppNMFcbAY&j?AhRJiK^8&ofjkU(3i2}KEyzcZ zZy?82_`{hz!VgfHfxmaDyn(+TLyoApF)AlRQXs7$9UvD#3RQTt=g$M)19=?6BlU@s_y5UA?ynii!>`Y; z#27jk!sB=e{_;5fm4oQL@M}p=asV4pq}uO%Qv$w3%)j+H>o372y03mz8nzpEH7LM^ zWTd`=#RtHe!Jj&qH=E zSW?c926pqK0o;xGBRhSbJqp8PV(11B7okaf_lUpAp?f>%DWRLbaxAzOv&KbkGVN&g zT_ki)PHqd4no}{WDDhIF7ihfvi9Wm|*@wx(R#GwlfShFuAiE5d?Z{q@lWpP%d6I>t!o0WbM%3mXVPjNe zattogQ@hD0yv$9O!T8S>=!e z+{3zhqulmjY}_?t@m6MP)Z-srP(B%mY#G&U2H$Om8Jo)Zoa@gk@ z`djG{o+iTU`yIqH@ZRUTV)Gx|_F>&2-~2s@RxIt!{m@Z*Y^C#RFo7?`!zSuPPKla6D zyno`m3Ps&!x8c=zG%Br!Eds41U$&EX87%D_YEv9M5Th`IH!K8e)f+mJl9DF`4`XLY0OhGBjgz0U5$n;UZ52`lZ4&52L1qkIi0ysh0d z1HRksdXD3Ieu)l}^%Y>Eth=YY-z{BtPk9ou88crrWb^qx2NrqNi6$!m*Cr>+IuR^x z2t2!QfhOX)JVPtGwNIZ z4lMGV)aX+Az6*aIrY2_;dU~C_q|o-~VngjX4CTViNj`_Bp6R<59RQO!>~4Y9aHK{$ zl3Y026*n8g_vCR&9A1^skq_(W0X+Y|4tZd@WN2?tyCXR%`%0_y5RO2Qw?~uCC0$8c z6kBcZezUJtxO9FaI+L_!O_bm{qVzl?itdMLmt)6&R*vK(yRH9=a-0_BPs)Lp0{=;S zr2hBiI4#OK%i$n?R*UJwVdcOGhvPE7&N7BN(?IJiU#R&~C4c%6Q3Lh|Bx`pZr|bqv zWjMT+e1k^5E?H*|sP2Wq<-j|R|NG_O^)2TpN3vZGo|B{Hz?7rVw9l||?D>D99Qa`8 zxyq4Zm%~|G4xVaS^Am!x%|WBl9(&JHj)C?X1+Wx^oNZn{Y9D1cb|W-I2VNe zF0=A0YIF>@{QYp$JSG$-K^69f!*Xn$gdcIjjP^77Sht!1g~uQy67AsUjsVb4q(_d@?kx%r9xxziRlJZ+0`r9^m{i9KbWLZ2wb zTu8oVlJ`yc-LEsW+rJ!TxR%Fzs3+ivUgCC@;_3mnkJIkQ=aFSyqfEw}wt~Nw{3IxQ z^7d+Wva`TsbN%8a;%82K{LIfPXT(k0z@c~-=4+bZlYYwYkhh|&)l$~wU^0Hkb#3^^ zLUEy-laLaP4}anoGQH;Ues)s*XiAH=Z|E?VCzreQZtjy=HP^IWB+dVB#ue+GkQI>U zA^hTOJ%q1h{{cDsbuN4SSJ%08#&z!Bo}{SzPyjyn`5pX$vmEbP|LvHppLIr`J!^b42^cBp}5A{QztIHyk)G9rKqmlJBKyJTlc5=tzovhy=)KAc1 zx1BmYY9h|ylQ^qo{|=s+j40UrK!VVb(Urq^KEdnqTh6b*ruM%e0eoYTzgCDCEg)mU zclRy}twy32=L+XGZ;E)IOWjIqu7Popf~NCg{h);zgxMZ))Dw*}IiDOsZn+7e!3yy^ zkpny9)&{T-vajRQjvT3BE(AM0+?I4vlQYAx?QCt*HTOdfq#p{l<6{5JPyjd$E1P_J z7#b_wFEsvg8-`ppt|#12!t(0IRX<0#AMXdx<1HRlh5C!#ocLWi%XrJL6wf_w30pgE zaXZI_WyW@1m@VZ&!-NId?cg~}7~Wf-;TJqhSlL;^&;ibfi{IKa!?5*ls8P`-c6$ZS z5|($Cu(Gp+VYAya(!<8fXNHA0Q>ZWGh5Ln$JGyesaSw%|xy}efbDa^!CtfJ)P+Z<` z`;0I|J|ir6max3qu+X&-?lR8kM`71Oh;i;~A-Ui?%e7DeZq4dm3)$CQU;g{N%Klwm za#44dyskJSFZ*8Pt2%jMd^`JfSIU2X-E~@&b6j_wKV%?g+Vau2pX<%+(5g+V_HEj? z?ZP1uG>O9(6E*rP(JcJkeg*U)Gp1cNxnw$f^vBfxQ*97-`4H;U%<#^R)TrO(1Nz|a zWw7(n7LCrIR9eK&_=nTd3~TVP*BcAtmnQ8g(SB$8cbGAdrf}fLhC}eT3yL)yVH425 zFu9oA(8nX}E$H#kxzte*n1m=IcrJv0>#neCIL@zl}N)RRc1o)Ml@ z+U42ganX04btaM8dh2^rX{2`(*oVA#LEjBMmE1nYF@jqJTSjrn-snx9bQ&1bJSLs) z1~#O(Vs=6w63Zbk1e(XB(&&1dJWc7X)HSK8^jX>_PdvTYqbYJ6o5wkJ>czR-bv~!I zqxU9{j~?tdv!9E$UA_)A{X+1lVDq6I(sO95p)PuP=mWsd5Ryv&8p@^pV`zPEJS7in ziuBWgsnlo~mo0l(^O$&Qi;zU>JgmOgMZJb`tSi7K(rkpJ(woq~rM{SrluC2*xg>uB z#?!WZPHl(aCxQvXIptQv*=M|9IWV2x8{Ryoh14sRvPUr69@t7So%)X8)+hkBkP^0# z5~kBl2uUT^$W5NxsXHbrrqVd*@icEF=khi5MCv_?+vnX;oaS#pA9Wl(v!9PH2D)h0 zXzmH~Mh9@If4k@p3;Q%ee6(4@cOu+H)xxHa;qb147YLRL&K6tpd6mn^&7jil8Eac<$df_vL zF8UOhNT&+xdlRYNSjO|mwixT8;bWgE^wHF@oY$>m130-}9lHYIACBepk0QiHO^e(` zF6vsuy}GDqq!mNY7I8m+yJ($hM_(501AFDT2Zpwz`9K%FIPQ^giL`ax2=uoB#m^L; z=NMhgC7)Ex>>|O<#jA=jN1^zUaW49$nA7)M!FnUX9)iOJrwHBw@p2De=CiQ{blYQ$^(0#B`>E1IsM<}l)@w|Soiz-mElagQDZ zIvg#5jU8Qq104M*lbSde1D9AmO(s=Zy@AhI{mqcFPpyf-gMvo|zZd*PkRq7%2>Jz6 z1RDYaloPQC*dgLBU>DIZ01hd;DB^D5VDZeCkdfkFEItz>o`nB2i8WV3Zj_M45l*DfqSEF~J`NPYV7fXk1*v2tl7?L@C;9mp>30^KZLa;!vSa7`H)q+z6X9`{~_*cOj1aB6+ zP4G^^y9MtPTrRjm@KM)5=a8~hEJ5=Ax5yC zU<1J>f;oa61iK6N7aSxwLU6obso+e(If6F;19Y3a${C=0q5J6-_Zv<>9dW-6yv6e^ z@DGo}GStl*3ml8RSPiZ6HUw6C+XCZ!dBDy-*01ng0=!x9al!X}V-WJK=y8$EwiUco zaJt}9!51Rgb5|s%^PA|oQCCAB6~*D#3oa9UQE-Rg3GqpcX3q}M>^W9&p5TLmFAE-s zo&$Dx%rArc2{Em*)gO6g)0i z&(GoQ1qTb33f>|3q~JS(2L=BSOpWJQ9R&voP87UZaE0JT!QJs(P7~nrWCS=?p5WL3 z*X4G>*8=ZCKP-A6fjv7XuxGyLGX?*i!2WLw9v954$DTa}OX}^1zC`p_1^-o#(@aj} zSbYVj2|kp_Ew(3-*@z_0rKw;)!SRB(3a%1-Pw=Q=pgE zU~CHew-D?rSSUC!9A(}LU?L@_UR}%v_5;@ zDEcGyxiwxF{d3Vx8hbWOVlOYa4KRo)`R9 zLgLbyZJW+HjuE_FaD6(bvtQVs1>-ZgB%LzYbDZGf49;b(;2yzK8Jt>!AY+dpvqhrc zDELT_%k!S#_kt;z?AbMwJ;w;%kjd#kBe*}4>sYU$owst+XxPB!m<7;`jdit z1S6WVPp~Po7YSZ3__*K>LDP(VG6cIf<1&m9oF`ZzxJmG{W}HrJ7GpQTs|4>6tjglJ zp9ubu#jV=3IfwKU94~mQ;Hu`_w(pDnZF4^QSuNP}f))O^F>t4a<1>YAuENq|+d*%sV zE%@&O_=XHHMIh)#XU3N&w_wD$sNo>#I zT?NOq=a3uPvwuZ2a zCwNpax)Xc061+rkN+(Y3PSKy~#Ch%S#3_3_b9l4P?B8GTs?N;*tuwQ42zx-n9l7k& zNU)FK6}jwrx8Q5JoX*FBzY3;wVgIgzBL(MlVgDxtcL`Eg4rwVkLhzQZobR)O9|=aB z$3E=@3j`MlZa9zA-zWI1gk*K&kOAG;f2Lq1LWY*T-K`4u1|N1?gu9e|-KIyl=uo$7 zf!_(9>h>hUo!vP+wma)7-I;AJA?*ZvNXTEha|)M=&xq~=k!GQUj~ARGA%7MBJG#$C z3d_1L06r@It0jDG_d5~tns{y#pWPDviQv)hcOm^B1x*hrPmh64Cnfc$0tS0LX`Iwl zu%%!p!JhDRQvV)LgB>I|R6@oIJE6x!gijZJwy-ydzDV$%9*e*}AbMqw*+}PciMvKZ zHuks=A)5u?5&Wm%9>D_=_po?=FL+YW>Uk|~c_2e@5 z02=DubE3gfV|1*z;4Wa*1+0I0!9b^Rc=|mJJzMaSeiyoowA+0 zYnEE|9UWmURjZ5Rd{}G5y1+5dF%H&twH7+YSxg&u@XIVoe#n@cN^!I z=(*GRIPNc(sr88SIer$k-R3qrU&S3|p<0hP-@`MhvKsC~Jk?rkTeQ!)A9tl2)%wwS zkOFj2tz_#Psz-f3kTfaT`i)X(eT@}s8qlZ@nRB9?gG?sPu`SwY6`01fQmqfHD@_wR zDwbXMrgTCq`xrH)v>lvE!1IgyJ!exYRx8G{9o8JRQaw9iEmW(U=Obq`+9;NtN;BFa zmYqX0sunBJbD!r2c%IOBPl^?{lk*G33yKwr*I~DC^qJ>3#Ot$%tv(K~*JowXQn4^% zdjq)ZuHbFUsdwa6-XyCzt%ntaHN%?*D|wI2t@AduT2LEU%)O0Cnk{Ita$kEpTG_Nx zxs%?mu+}P9-`B^=p{>d__YHuxN4fKT9j%shOu0e6uCPuiH`zDDYDEcq?fkCy<-?i* zi_3WzxYo2txd*_trlZQO0oR7CeRjN!;M!0zERMI^S7f!NIm&(RD}l98xf6)jjw+P1 zBJ*LfxeLH`pkvC71lN%~`|Wro;5yQHSX`Dl z;5t#6atpzAqH5(H1lO5PDE9=o&XoVL9q-l1A}g1sz~ZvJ8(9Ktj&cVgJ6c_6sdC>& zc7=6ZxyYy@t1Cr)V#iC1DuI;@i_3C;)Ku#{YNOmGQ8QsJR<0QFy3tDIN)fLctyS&@ zaNTLEa(961PJ5KA0M~<#Dfc9}9&}2%SHbn9gir0VyaTQ$1z~YnJ^`0UxypSFE|2;s zN6}NQUNlO%$mp4{HY%46?tI#zTyt>eQ-^9h&0f((R&Tlx7Pr~p=n`1@%3TGn4^2^S z2Dm;nN4Z~#a%;d{K%13&16)7auiX3K`q3ffzK$-l`r`$( zU6vEkH^GX6#dV($bC)%M8Y}nLn5D4VD7P}E+!{#zm0K563F|WDzKwax`U_1`&Kdh0 ztXax6kA2FzkQOV~1KfplOu6Z?uUHq6=QF!3x5T~yD*+alWi{emOgYL`A>PH5tK1jh zE}=onodkCYjZ!WtuFM)lGn8u_cN45K<+{X8wFc8N<@&_Ugmpr>Vc;&MxXx zroiH|%!=z{4WWg~-5fUn)>7q`#}!$Z(Q4%$k1K(-Ub&aST~6DTdmG&4v|qXX;D*w1 z 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 literal 342016 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