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));
}
}
/// <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;
}
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);
}
/// <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;
}
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);
}
}
