diff --git a/TBF/Properties/AssemblyInfo.cs b/TBF/Properties/AssemblyInfo.cs index e05f7a9c7..d851f9749 100644 --- a/TBF/Properties/AssemblyInfo.cs +++ b/TBF/Properties/AssemblyInfo.cs @@ -29,5 +29,5 @@ using System.Runtime.InteropServices; // Build Number // Revision // -[assembly: AssemblyVersion("2.28.1924.0")] -[assembly: AssemblyFileVersion("2.28.1924.0")] +[assembly: AssemblyVersion("2.28.1925.0")] +[assembly: AssemblyFileVersion("2.28.1925.0")] diff --git a/TBF/Rig/RegisterReaders/DataStream/Reader/ProcParams.cs b/TBF/Rig/RegisterReaders/DataStream/Reader/ProcParams.cs new file mode 100644 index 000000000..9edd743af --- /dev/null +++ b/TBF/Rig/RegisterReaders/DataStream/Reader/ProcParams.cs @@ -0,0 +1,223 @@ +/// +/// Copyright (c) 2022 Sensus Slovensko a.s. +/// +using System; +using System.Collections.Generic; +using System.IO; +using System.Xml.Serialization; +using Common; +using Config.Entities; +using TBF.Resources; +using TBF.Rig.Generic; +using TBF.Rig.Sequences; + +namespace TBF.Rig.RegisterReaders.DataStream.Reader +{ + public enum UnitsSource + { + [Description("From MEF component")] FromMefComponent, + [Description("As defined")] AsDefined, + Count + } + + public class ProcParams : ProcedureParamsBase, IParamsProvider, IProcedureParams + { + public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(ProcParams) })[0]; + public override XmlSerializer GetSerializer() { return Serializer; } + + public UnitsSource UnitsSource; + public Unit TimeUnit; + public double TimeFactor; + public Unit VolumeUnit; + public double VolumeFactor; + + public override void InitializeAll() + { + UnitsSource = UnitsSource.FromMefComponent; + TimeUnit = Unit.s; + TimeFactor = 1.0; + VolumeUnit = Unit.l; + VolumeFactor = 1.0; + } + + string[] paramNames = new string[] + { + "Units source", + "Unit of time", + "Time factor", + "Unit of volume", + "Volume factor", + }; + public override string ParamName(int i) { return paramNames[i]; } + public override int ParamsCount() { return paramNames.Length; } + + public ICollection ParamValues(int i) + { + var values = new List(); + + switch (i) + { + case 0: + for (UnitsSource us = 0; us < UnitsSource.Count; us++) values.Add(us.ToDescription()); + return values; + case 1: + for (Unit tu = 0; tu < Unit.Count; tu++) if (Units.IsTime(tu)) values.Add(tu.ToDescription()); + return values; + case 3: + for (Unit vu = 0; vu < Unit.Count; vu++) if (Units.IsVolume(vu)) values.Add(vu.ToDescription()); + return values; + case 2: + case 4: + default: + return null; + } + } + + public override string ToString(int i) + { + switch (i) + { + case 0: return UnitsSource.ToDescription(); + case 1: return TimeUnit.ToDescription(); + case 2: return TimeFactor.ToString(); + case 3: return VolumeUnit.ToDescription(); + case 4: return VolumeFactor.ToString(); + default: return string.Empty; + } + } + + public CfgUpdateFlags UpdateParam(int i, string str) + { + switch (i) + { + case 0: + for (UnitsSource us = 0; us < UnitsSource.Count; us++) + if (us.ToDescription() == str) + { + UnitsSource = us; + return CfgUpdateFlags.RestartRqrd; + } + return CfgUpdateFlags.None; + case 1: + for (Unit tu = 0; tu < Unit.Count; tu++) + if (Units.IsTime(tu) && tu.ToDescription() == str) + { + TimeUnit = tu; + return CfgUpdateFlags.RestartRqrd; + } + return CfgUpdateFlags.None; + case 2: + TimeFactor = Utils.ParseUDouble(str); + return CfgUpdateFlags.RestartRqrd; + case 3: + for (Unit vu = 0; vu < Unit.Count; vu++) + if (Units.IsVolume(vu) && vu.ToDescription() == str) + { + VolumeUnit = vu; + return CfgUpdateFlags.RestartRqrd; + } + return CfgUpdateFlags.None; + case 4: + VolumeFactor = Utils.ParseUDouble(str); + return CfgUpdateFlags.RestartRqrd; + default: + return CfgUpdateFlags.None; + } + } + + /// + /// Verifiy the string representation of the parameter + /// + /// Parameter ID + /// String representation of the parameter + /// In case false is returned this is the error messsage to be displayed + /// true = parameter OK, false = parameter NOK + public bool ValidateParam(int i, string str, out string message) + { + message = string.Empty; + + double ddummy; + switch (i) + { + case 0: + for (UnitsSource us = 0; us < UnitsSource.Count; us++) + if (us.ToDescription() == str) + return true; + break; + case 1: + for (Unit tu = 0; tu < Unit.Count; tu++) + if (Units.IsTime(tu) && tu.ToDescription() == str) + return true; + break; + case 2: + case 4: + if (Utils.TryParseUDouble(str, out ddummy)) return true; + break; + case 3: + for (Unit vu = 0; vu < Unit.Count; vu++) + if (Units.IsVolume(vu) && vu.ToDescription() == str) + return true; + break; + default: + message = "Invalid index"; + return false; + } + + message = ParamName(i) + " is invalid"; + return false; + } + + void CopyContentTo(ProcParams prms) + { + prms.UnitsSource = UnitsSource; + prms.TimeUnit = TimeUnit; + prms.TimeFactor = TimeFactor; + prms.VolumeUnit = VolumeUnit; + prms.VolumeFactor = VolumeFactor; + } + + public IParamsProvider Clone() + { + ProcParams pars = new ProcParams(); + CopyContentTo(pars); + return pars; + } + + public override void UpdateFromDbEntity(ComponentProcedure dbEntity) + { + if (dbEntity == null) return; + try + { + ProcParams tmp = Serializer.Deserialize(new StringReader(dbEntity.Parameters)) as ProcParams; + + procedureParamsEntity = dbEntity; + componentName = dbEntity.CmpntName; + procedure = dbEntity.Procedure; + + if (tmp != null) tmp.CopyContentTo(this); + } + catch + { + } + } + + /// + /// Parameterless constructor initializes the parameters + /// + public ProcParams() + { + } + + public ProcParams(bool initialize) + { + if (initialize) InitializeAll(); + } + + public ProcParams(ComponentProcedure procParamsEntity, string componentName, Procedure procedure) + { + this.procedureParamsEntity = procParamsEntity; + this.componentName = componentName; + this.procedure = procedure; + } + } +} diff --git a/TBF/Rig/RegisterReaders/DataStream/Reader/Reader.cs b/TBF/Rig/RegisterReaders/DataStream/Reader/Reader.cs index ed7993c3f..105d7a12c 100644 --- a/TBF/Rig/RegisterReaders/DataStream/Reader/Reader.cs +++ b/TBF/Rig/RegisterReaders/DataStream/Reader/Reader.cs @@ -1,5 +1,5 @@ /// -/// Copyright (c) 2021 Sensus Slovensko a.s. +/// Copyright (c) 2021-2022 Sensus Slovensko a.s. /// using System; using System.Collections.Generic; @@ -12,6 +12,7 @@ using DataStreamInterface; using TBF.Rig; using TBF.Rig.Generic; using TBF.Rig.RegisterReaders.DataStream; +using TBF.Rig.Sequences; namespace TBF.Rig.RegisterReaders.DataStream.Reader { @@ -35,6 +36,12 @@ namespace TBF.Rig.RegisterReaders.DataStream.Reader public double PulsesPerLtr { get { return 1.0; } } public double LtrsPerPulse { get { return 1.0; } } + public UnitsSource UnitsSource { get { return (myCfg != null && myCfg.ProcParams != null) ? myCfg.ProcParams.UnitsSource : UnitsSource.AsDefined; } } + public Common.Unit AsDefTimeUnit { get { return (myCfg != null && myCfg.ProcParams != null) ? myCfg.ProcParams.TimeUnit : Common.Unit.s; } } + public Common.Unit AsDefVolumeUnit { get { return (myCfg != null && myCfg.ProcParams != null) ? myCfg.ProcParams.VolumeUnit : Common.Unit.l; } } + public double AsDefTimeFactor { get { return (myCfg != null && myCfg.ProcParams != null) ? myCfg.ProcParams.TimeFactor : 1.0; } } + public double AsDefVolumeFactor { get { return (myCfg != null && myCfg.ProcParams != null) ? myCfg.ProcParams.VolumeFactor : 1.0; } } + string waterMeterID; Int64 storedFramesCount; Int64 startIx; @@ -136,12 +143,13 @@ namespace TBF.Rig.RegisterReaders.DataStream.Reader { Clear(); - if (TBF.Rig.Sequences.ProcessData.BatchRslts.Batch.WaterMeters.Count >= Position && - TBF.Rig.Sequences.ProcessData.BatchRslts.Batch.WaterMeters[Position - 1] != null && - !TBF.Rig.Sequences.ProcessData.BatchRslts.Batch.WaterMeters[Position - 1].Disabled) + if (ProcessData.BatchRslts.Batch.WaterMeters.Count >= Position && + ProcessData.BatchRslts.Batch.WaterMeters[Position - 1] != null && + !ProcessData.BatchRslts.Batch.WaterMeters[Position - 1].Disabled) { timeUnit = mefImport.DataStreamIFace.GetTimeUnits(); volumeUnit = mefImport.DataStreamIFace.GetVolumeUnits(); + log.DebugFormat("timeUnit = {0}, volumeUnit = {1}", timeUnit, volumeUnit); bool started = mefImport.StartMeasurement(Position - 1); @@ -158,9 +166,9 @@ namespace TBF.Rig.RegisterReaders.DataStream.Reader public void Stop() { - if (TBF.Rig.Sequences.ProcessData.BatchRslts.Batch.WaterMeters.Count >= Position && - TBF.Rig.Sequences.ProcessData.BatchRslts.Batch.WaterMeters[Position - 1] != null && - !TBF.Rig.Sequences.ProcessData.BatchRslts.Batch.WaterMeters[Position - 1].Disabled) + if (ProcessData.BatchRslts.Batch.WaterMeters.Count >= Position && + ProcessData.BatchRslts.Batch.WaterMeters[Position - 1] != null && + !ProcessData.BatchRslts.Batch.WaterMeters[Position - 1].Disabled) { bool stopped = mefImport.StopMeasurement(Position - 1, out storedFramesCount); log.DebugFormat("{0} : DataStreamIFace.StopMeasurement({1}) in Stop() returned {2}, storedFramesCount = {3}", Name, Position - 1, stopped, storedFramesCount); @@ -199,14 +207,18 @@ namespace TBF.Rig.RegisterReaders.DataStream.Reader if (samplesDict.TryGetValue(ix, out oneFrame)) { - double time = DataStreamInterface.Units.ConvertFrom(timeUnit, oneFrame.Time); + double time = (UnitsSource == UnitsSource.FromMefComponent) + ? DataStreamInterface.Units.ConvertFrom(timeUnit, oneFrame.Time) + : AsDefTimeFactor * Common.Units.ConvertFrom(AsDefTimeUnit, oneFrame.Time); log.DebugFormat("GetTimeFromSamples({0}) returns {1} ... value from dictionary", ix, time); return time; } else if ((frames = mefImport.DataStreamIFace.GetFrames(Position - 1, ix, 1)).Length == 1) { samplesDict.Add(ix, frames[0]); - double time = DataStreamInterface.Units.ConvertFrom(timeUnit, frames[0].Time); + double time = (UnitsSource == UnitsSource.FromMefComponent) + ? DataStreamInterface.Units.ConvertFrom(timeUnit, frames[0].Time) + : AsDefTimeFactor * Common.Units.ConvertFrom(AsDefTimeUnit, frames[0].Time); log.DebugFormat("GetTimeFromSamples({0}) returns {1} ... value obtained by DataStreamIFace.GetFrames({2}, {0}, 1)", ix, time, Position - 1); return time; } @@ -224,14 +236,18 @@ namespace TBF.Rig.RegisterReaders.DataStream.Reader if (samplesDict.TryGetValue(ix, out oneFrame)) { - double volume = DataStreamInterface.Units.ConvertFrom(volumeUnit, oneFrame.Volume); + double volume = (UnitsSource == UnitsSource.FromMefComponent) + ? DataStreamInterface.Units.ConvertFrom(volumeUnit, oneFrame.Volume) + : AsDefVolumeFactor * Common.Units.ConvertFrom(AsDefVolumeUnit, oneFrame.Volume); log.DebugFormat("GetVolumeFromSamples({0}) returns {1} ... value from dictionary", ix, volume); return volume; } else if ((frames = mefImport.DataStreamIFace.GetFrames(Position - 1, ix, 1)).Length == 1) { samplesDict.Add(ix, frames[0]); - double volume = DataStreamInterface.Units.ConvertFrom(volumeUnit, frames[0].Volume); + double volume = (UnitsSource == UnitsSource.FromMefComponent) + ? DataStreamInterface.Units.ConvertFrom(volumeUnit, frames[0].Volume) + : AsDefVolumeFactor * Common.Units.ConvertFrom(AsDefVolumeUnit, frames[0].Volume); log.DebugFormat("GetVolumeFromSamples({0}) returns {1} ... value obtained by DataStreamIFace.GetFrames({2}, {0}, 1)", ix, volume, Position - 1); return volume; } diff --git a/TBF/Rig/RegisterReaders/DataStream/Reader/ReaderCfg.cs b/TBF/Rig/RegisterReaders/DataStream/Reader/ReaderCfg.cs index bfdf6476b..55ba89799 100644 --- a/TBF/Rig/RegisterReaders/DataStream/Reader/ReaderCfg.cs +++ b/TBF/Rig/RegisterReaders/DataStream/Reader/ReaderCfg.cs @@ -1,5 +1,5 @@ /// -/// Copyright (c) 2021 Sensus Slovensko a.s. +/// Copyright (c) 2021-2022 Sensus Slovensko a.s. /// using System; using System.Collections.Generic; @@ -21,8 +21,9 @@ namespace TBF.Rig.RegisterReaders.DataStream.Reader public IComponentCfgCtrl GetControl(IList cmpntEntities) { IList parents = new List(); - parents.Add("MefImport"); - + foreach (var c in cmpntEntities) + if (c.ClassName == "RegisterReaders.DataStream.MefImport") + parents.Add(c.Name); return new Configs.ParamsProvider.ComponentCfgCtrl(this, parents); } @@ -32,15 +33,23 @@ namespace TBF.Rig.RegisterReaders.DataStream.Reader public int Position; + /// Procedure parameters + [XmlIgnore] + public ProcParams ProcParams; + public override IParamsProvider GetRuntimeProcParamsProvider() { return ProcParams; } + public override IParamsProvider CreateProcParamsProvider() { return new ProcParams(true); } + + /// Private parameterless constructor invoked by all other (public) constructors - ReaderCfg() {} + ReaderCfg() + { + ProcParams = new ProcParams(true); + } public ReaderCfg(IComponentFactory factory) : this() { - Factory = factory; - Name = "Reader"; - ParentName = "MefImport"; + this.Factory = factory; InitializeAll(); } @@ -48,6 +57,8 @@ namespace TBF.Rig.RegisterReaders.DataStream.Reader public void InitializeAll() { + Name = "Reader"; + ParentName = "MefImport"; Position = 1; } diff --git a/TBF/TBF.csproj b/TBF/TBF.csproj index 89432cf2c..b1b8363d2 100644 --- a/TBF/TBF.csproj +++ b/TBF/TBF.csproj @@ -1187,6 +1187,7 @@ +