public void MeasurementCombinationValueTest2() { var pin1 = new APin (); var pin2 = new APin (); var meCom1 = new MeasurementCombination (); pin1.Slope = 1; pin1.Offset = 0; pin1.MeanValuesCount = 2; pin1.Interval = 1; pin1.Number = 0; pin2.Slope = 1; pin2.Offset = 0; pin2.MeanValuesCount = 2; pin2.Interval = 1; pin2.Number = 1; pin1.Value = new DateTimeValue (1, DateTime.Now); pin1.Value = new DateTimeValue (1, DateTime.Now); pin2.Value = new DateTimeValue (1, DateTime.Now); pin2.Value = new DateTimeValue (1, DateTime.Now); meCom1.AddPin (pin1); meCom1.AddPin (pin2); meCom1.Operation = OperationCompiler.CompileOperation ("A0+A1", meCom1.Pins.Select (o => o.DisplayNumberShort).ToArray ()); Assert.AreEqual (2, meCom1.Value.Value); }
/// <summary> /// Edits the measurment combination. /// </summary> /// <param name="index">Index.</param> /// <param name="s">S.</param> public void EditMeasurmentCombination(int index, MeasurementCombination s) { if (OnSignalsUpdated != null) { OnSignalsUpdated.Invoke(this, new MeasurementCombinationsUpdatedArgs(UpdateOperation.Change, MeasurementCombinations [index], s)); } MeasurementCombinations [index] = s; }
public void SignalConstructorTest() { MeasurementCombination signal = new MeasurementCombination (); signal.Color = ColorHelper.SystemColorToGdkColor (System.Drawing.Color.Blue); Assert.AreEqual (0, signal.Pins.Count); Assert.AreEqual (string.Empty, signal.Name); Assert.AreEqual (ColorHelper.SystemColorToGdkColor (System.Drawing.Color.Blue), signal.Color); Assert.AreEqual (string.Empty, signal.OperationString); }
/// <summary> /// Initializes a new instance of the <see cref="PrototypeBackend.MeasurementCombination"/> class. /// </summary> /// <param name="copy">Copy.</param> public MeasurementCombination(MeasurementCombination copy) : base() { Pins = copy.Pins; Name = copy.Name; Color = copy.Color; Operation = copy.Operation; OperationString = copy.OperationString; Unit = copy.Unit; MeanValuesCount = copy.MeanValuesCount; Values = copy.Values; }
/// <summary> /// Removes the measurement combination. /// </summary> /// <param name="index">Index.</param> public void RemoveMeasurementCombination(MeasurementCombination index) { if (index != null) { if (OnSignalsUpdated != null) { OnSignalsUpdated.Invoke(this, new MeasurementCombinationsUpdatedArgs(UpdateOperation.Remove, index)); } MeasurementCombinations.Remove(index); } }
/// <summary> /// Adds a measurement combination. /// </summary> public void AddMeasurementCombination(MeasurementCombination s) { // if (!MeasurementCombinations.Contains (s)) // { MeasurementCombinations.Add(s); // } if (OnSignalsUpdated != null) { OnSignalsUpdated.Invoke(this, new MeasurementCombinationsUpdatedArgs(UpdateOperation.Add, s)); } }
/// <summary> /// Removes the measurement combination. /// </summary> /// <param name="index">Index.</param> public void RemoveMeasurementCombination(int index) { var sig = new MeasurementCombination(); sig = MeasurementCombinations [index]; MeasurementCombinations.RemoveAt(index); if (OnSignalsUpdated != null) { OnSignalsUpdated.Invoke(this, new MeasurementCombinationsUpdatedArgs(UpdateOperation.Remove, sig)); } }
public void MeasurementCombinationTests1() { var mecom = new MeasurementCombination (); var pin = new APin (){ Number = 0, RealNumber = 14, Interval = 1000, MeanValuesCount = 1 }; Assert.AreEqual (0, mecom.Pins.Count); mecom.AddPin (pin); Assert.AreEqual (1, mecom.Pins.Count); Assert.AreEqual (false, mecom.AddPin (pin)); var mecomcopy = new MeasurementCombination (); mecomcopy.AddPin (pin); Assert.AreEqual (mecom, mecomcopy); }
/// <summary> /// Determines whether the specified <see cref="System.Object"/> is equal to the current <see cref="PrototypeBackend.MeasurementCombination"/>. /// </summary> /// <param name="obj">The <see cref="System.Object"/> to compare with the current <see cref="PrototypeBackend.MeasurementCombination"/>.</param> /// <returns><c>true</c> if the specified <see cref="System.Object"/> is equal to the current /// <see cref="PrototypeBackend.MeasurementCombination"/>; otherwise, <c>false</c>.</returns> public override bool Equals(object obj) { MeasurementCombination MeCom = obj as MeasurementCombination; if (MeCom != null) { return (this.Pins.SequenceEqual(MeCom.Pins) && this.Name.Equals(MeCom.Name) && this.MeanValuesCount.Equals(MeCom.MeanValuesCount) && this.OperationString_.Equals(MeCom.OperationString_) && this.Interval.Equals(MeCom.Interval) && this.Unit.Equals(MeCom.Unit) && this.Color.Equal(MeCom.Color)); } return(false); }
/// <summary> /// Removes the measurement combination. /// </summary> /// <param name="index">Index.</param> public void RemoveMeasurementCombination(string index) { if (index != null) { var MeCom = new MeasurementCombination(); MeCom = MeasurementCombinations.Where(o => o.Name == index).ToList <MeasurementCombination> () [0]; if (OnSignalsUpdated != null) { OnSignalsUpdated.Invoke(this, new MeasurementCombinationsUpdatedArgs(UpdateOperation.Remove, MeCom)); } MeasurementCombinations.Remove(MeCom); } else { throw new ArgumentNullException(); } }
public void SignalPinsTest() { MeasurementCombination signal = new MeasurementCombination (); signal.Pins.Add (new APin () { Name = "Temp1", Number = 0 }); signal.OperationString = "A0"; signal.Operation = Backend.OperationCompiler.CompileOperation ( signal.OperationString, new string[]{ "A0" } ); Assert.AreEqual (1, signal.Pins.Count); signal.Pins [0].Values.Add (new DateTimeValue (42, DateTime.Now)); string func = "Temp1"; signal.OperationString = func; Assert.AreEqual (42, signal.Value.Value); }
public void SerializeBoardConfigTest2() { var conf = new BoardConfiguration (); conf.Board.AnalogReferenceVoltageType = "INTERNAL"; conf.Board.AnalogReferenceVoltage = 4.24; var pin = new APin (){ Number = 42 }; var MeCom = new MeasurementCombination (); MeCom.AddPin (pin); conf.AddPin (pin); conf.AddMeasurementCombination (MeCom); Formator.Serialize (MemStream, conf); MemStream.Seek (0, SeekOrigin.Begin); var confClone = (BoardConfiguration)Formator.Deserialize (MemStream); Assert.AreEqual (conf.Pins [0], confClone.Pins [0]); Assert.AreEqual (conf.MeasurementCombinations [0], confClone.MeasurementCombinations [0]); Assert.AreEqual (4.24, conf.Board.AnalogReferenceVoltage, 0.000000001); Assert.AreEqual (4.24, confClone.Board.AnalogReferenceVoltage, 0.000000001); Assert.AreEqual ("INTERNAL", conf.Board.AnalogReferenceVoltageType); Assert.AreEqual ("INTERNAL", confClone.Board.AnalogReferenceVoltageType); Assert.AreSame (conf.Pins [0], conf.MeasurementCombinations [0].Pins [0]); Assert.AreSame (confClone.Pins [0], confClone.MeasurementCombinations [0].Pins [0]); conf.Pins [0].Name = "Dulli"; Assert.AreEqual (conf.Pins [0].Name, conf.MeasurementCombinations [0].Pins [0].Name); Assert.AreEqual (19, confClone.AvailableDigitalPins.Length); Assert.AreEqual (6, confClone.AvailableAnalogPins.Length); conf.ClearPins (); Assert.AreEqual (0, conf.Pins.Count); Assert.AreEqual (0, conf.MeasurementCombinations.Count); }
public MeasurementCombinationTreeNode(MeasurementCombination analogSignal, int index = -1) { Index = index; AnalogSignal = analogSignal; Color = ColorHelper.ColoredPixbuf (AnalogSignal.Color); }
/// <summary> /// Initializes a new instance of the <see cref="AComConfigDialog"/> class. /// </summary> /// <param name="pins">Pins.</param> /// <param name="signal">Signal.</param> /// <param name="pin">Pin.</param> /// <param name="parent">Parent.</param> /// <param name="units">Units.</param> public AComConfigDialog(APin[] pins, MeasurementCombination signal = null, APin pin = null, Gtk.Window parent = null, List<string> units = null) : base("Analog Inputs Combinations - Dialog", parent, Gtk.DialogFlags.Modal, new object[0]) { this.Build (); sbMeanValuesCount.Adjustment.Upper = int.MaxValue; sbMeanValuesCount.Adjustment.Lower = 1; APins = pins; cbColor.Color = GUIHelper.ColorHelper.GetRandomGdkColor (); if (signal == null) { Combination_ = new MeasurementCombination (); Combination_.Color = cbColor.Color; } else { Combination = signal; if (!string.IsNullOrEmpty (Combination.OperationString)) { CompileOperation (); } else { SetWarning (); } buttonOk.Label = "Apply"; } if (pin != null) { Combination_.AddPin (pin); Combination_.Unit = Combination_.Pins [0].Unit; } SetupNodeView (); DrawNodeView (); UpdateCBPins (); SetApplyButton (); entryOperation.Activated += (sender, e) => { if (!CompileTimer.Enabled) { CompileTimer.Start (); } }; entryOperation.FocusInEvent += (sender, e) => { if (!CompileTimer.Enabled) { CompileTimer.Start (); } }; CompileTimer.Elapsed += CompileTimerElapsed; Units = units; ListStore store = new ListStore (typeof(string)); Units.ForEach (o => store.AppendValues (new object[]{ o })); cbeUnit.Model = store; if (!string.IsNullOrEmpty (Combination_.Unit)) { if (Units.Contains (Combination_.Unit)) { cbeUnit.Active = Array.IndexOf (Units.ToArray (), Combination_.Unit); } else { store.AppendValues (new string[]{ Combination_.Unit }); cbeUnit.Active = Units.Count; } } }
/// <summary> /// Adds a measurement combination. /// </summary> public void AddMeasurementCombination(MeasurementCombination s) { // if (!MeasurementCombinations.Contains (s)) // { MeasurementCombinations.Add (s); // } if (OnSignalsUpdated != null) { OnSignalsUpdated.Invoke (this, new MeasurementCombinationsUpdatedArgs (UpdateOperation.Add, s)); } }
private void RunMeasurementCombinationDialog (MeasurementCombination sig = null, APin refPin = null) { var dialog = new AComConfigDialog (con.Configuration.GetPinsWithoutCombinations (), sig, refPin, this, this.Units); dialog.Response += (o, args) => { if (args.ResponseId == ResponseType.Apply) { if (sig == null) { con.Configuration.AddMeasurementCombination (dialog.Combination); } else { con.Configuration.EditMeasurmentCombination (con.Configuration.MeasurementCombinations.IndexOf (sig), dialog.Combination); } } }; dialog.Run (); dialog.Destroy (); }
/// <summary> /// Clones a measurement combination. /// </summary> /// <param name="meCom">Me COM.</param> public void CloneMeasurementCombination(MeasurementCombination meCom) { MeasurementCombination copy = new MeasurementCombination(meCom); AddMeasurementCombination(copy); }
public void SerializeMeasurementCombination() { APin oPinionAtor = new APin () { Number = 42, }; MeasurementCombination MeCom = new MeasurementCombination () { Pins = new System.Collections.Generic.List<APin> (){ oPinionAtor }, OperationString = "A42" }; Formator.Serialize (MemStream, MeCom); MemStream.Seek (0, SeekOrigin.Begin); MeasurementCombination MeComCopy = new MeasurementCombination (); try { MeComCopy = (MeasurementCombination)Formator.Deserialize (MemStream); } catch (Exception e) { Console.WriteLine (e); } Assert.AreEqual (MeCom.Pins [0], MeComCopy.Pins [0]); Assert.AreEqual (MeCom, MeComCopy); }
/// <summary> /// Initializes a new instance of the <see cref="PrototypeBackend.MeasurementCombinationsUpdatedArgs"/> class. /// </summary> /// <param name="sigUpdateOperation">Sig update operation.</param> /// <param name="oldmecom">The old measurementcombination.</param> /// <param name="newmecom">The new measurementcombination.</param> public MeasurementCombinationsUpdatedArgs(UpdateOperation sigUpdateOperation, MeasurementCombination oldmecom = null, MeasurementCombination newmecom = null) { OldMeCom = oldmecom; NewMeCom = newmecom; UpdateOperation = sigUpdateOperation; }
/// <summary> /// Clones a measurement combination. /// </summary> /// <param name="meCom">Me COM.</param> public void CloneMeasurementCombination(MeasurementCombination meCom) { MeasurementCombination copy = new MeasurementCombination (meCom); AddMeasurementCombination (copy); }
/// <summary> /// Edits the measurment combination. /// </summary> /// <param name="index">Index.</param> /// <param name="s">S.</param> public void EditMeasurmentCombination(int index, MeasurementCombination s) { if (OnSignalsUpdated != null) { OnSignalsUpdated.Invoke (this, new MeasurementCombinationsUpdatedArgs (UpdateOperation.Change, MeasurementCombinations [index], s)); } MeasurementCombinations [index] = s; }
public void SerializeMeasurementCombinationWithoutPins() { MeasurementCombination MeCom = new MeasurementCombination () { OperationString = "A42" }; Formator.Serialize (MemStream, MeCom); MemStream.Seek (0, SeekOrigin.Begin); MeasurementCombination MeComCopy = (MeasurementCombination)Formator.Deserialize (MemStream); Assert.AreEqual (MeCom.Pins.Count, MeComCopy.Pins.Count); Assert.AreEqual (MeCom, MeComCopy); }
public APinTreeNode(APin pin, int index = -1, MeasurementCombination combination = null) { Pin = pin; Combination = combination; Index = index; }
/// <summary> /// Removes the measurement combination. /// </summary> /// <param name="index">Index.</param> public void RemoveMeasurementCombination(int index) { var sig = new MeasurementCombination (); sig = MeasurementCombinations [index]; MeasurementCombinations.RemoveAt (index); if (OnSignalsUpdated != null) { OnSignalsUpdated.Invoke (this, new MeasurementCombinationsUpdatedArgs (UpdateOperation.Remove, sig)); } }
/// <summary> /// Removes the measurement combination. /// </summary> /// <param name="index">Index.</param> public void RemoveMeasurementCombination(string index) { if (index != null) { var MeCom = new MeasurementCombination (); MeCom = MeasurementCombinations.Where (o => o.Name == index).ToList<MeasurementCombination> () [0]; if (OnSignalsUpdated != null) { OnSignalsUpdated.Invoke (this, new MeasurementCombinationsUpdatedArgs (UpdateOperation.Remove, MeCom)); } MeasurementCombinations.Remove (MeCom); } else { throw new ArgumentNullException (); } }
/// <summary> /// Removes the measurement combination. /// </summary> /// <param name="index">Index.</param> public void RemoveMeasurementCombination(MeasurementCombination index) { if (index != null) { if (OnSignalsUpdated != null) { OnSignalsUpdated.Invoke (this, new MeasurementCombinationsUpdatedArgs (UpdateOperation.Remove, index)); } MeasurementCombinations.Remove (index); } }