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);
}
public void APinConstructorTests()
{
var pin = new APin ();
Assert.AreEqual (Backend.PinType.ANALOG, pin.Type);
Assert.AreEqual (Backend.PinMode.INPUT, pin.Mode);
pin.PlotColor = new Gdk.Color (255, 0, 0);
Assert.AreEqual (new Gdk.Color (255, 0, 0), pin.PlotColor);
}
public void APinEqualsTest()
{
var pin1 = new APin ();
var pin2 = new APin ();
Assert.AreEqual (true, pin1.Equals (pin2));
pin1.PlotColor = new Color (0, 255, 0);
pin2.PlotColor = new Color (0, 255, 255);
Assert.AreEqual (false, pin1.Equals (pin2));
}
public void APinNewValueEventTest()
{
double val = -1;
var pin = new APin ();
pin.OnNewValue += (o, args) => val = args.Value;
pin.Value = new DateTimeValue (42.0, DateTime.Now);
Assert.AreEqual (42, val);
pin.Value = new DateTimeValue (43, DateTime.Now);
Assert.AreEqual (43, val);
}
public void APinCopyConstructorTest()
{
var pin = new APin ();
pin.Name = "PinPinsen";
pin.Interval = 3000;
double value = 42;
pin.Value = new DateTimeValue (value, DateTime.Now);
var copypin = new APin (pin);
Assert.AreEqual ("PinPinsen", copypin.Name);
Assert.AreEqual (3000, copypin.Interval);
Assert.AreEqual (value, copypin.Value.Value);
Assert.AreEqual (1, copypin.Values.Count);
Assert.AreEqual (pin.RAWValues, copypin.RAWValues);
}
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);
}
public void SerializeAPin()
{
APin TestPin = new APin () {
Number = 42,
Name = "TestPin",
PlotColor = GUIHelper.ColorHelper.GetRandomGdkColor (),
};
Formator.Serialize (MemStream, TestPin);
MemStream.Seek (0, SeekOrigin.Begin);
APin TestPinClone = (APin)Formator.Deserialize (MemStream);
Assert.AreEqual (TestPin, TestPinClone);
}
public void APinNewValueEventTestAfterEdit()
{
double val = -1;
var pin = new APin ();
pin.OnNewValue += (o, args) => val = args.Value;
pin.Value = new DateTimeValue (42, DateTime.Now);
Assert.AreEqual (42, val);
pin.Interval = 3000;
pin.OnNewValue = null;
pin.OnNewValue += (o, args) => val = args.Value * 2;
pin.Value = new DateTimeValue (42, DateTime.Now);
Assert.AreEqual (84, val);
}
/// <summary>
/// Initializes a new instance of the <see cref="PrototypeBackend.APin"/> class.
/// </summary>
/// <param name="copy">Copy.</param>
public APin(APin copy) : base()
{
Name = copy.Name;
Number = copy.Number;
DigitalNumber = copy.DigitalNumber;
PlotColor = copy.PlotColor;
Slope = copy.Slope;
Offset = copy.Offset;
MeanValuesCount = copy.MeanValuesCount;
Interval = copy.Interval;
Unit = copy.Unit;
Type = Backend.PinType.ANALOG;
Mode = Backend.PinMode.INPUT;
Values = copy.Values;
RAWValues = copy.RAWValues;
OnNewValue = copy.OnNewValue;
OnNewRAWValue = copy.OnNewRAWValue;
}
/// <summary>
/// Initializes a new instance of the <see cref="PrototypeBackend.APin"/> class.
/// </summary>
/// <param name="copy">Copy.</param>
public APin(APin copy)
: base()
{
Name = copy.Name;
Number = copy.Number;
DigitalNumber = copy.DigitalNumber;
PlotColor = copy.PlotColor;
Slope = copy.Slope;
Offset = copy.Offset;
MeanValuesCount = copy.MeanValuesCount;
Interval = copy.Interval;
Unit = copy.Unit;
Type = Backend.PinType.ANALOG;
Mode = Backend.PinMode.INPUT;
Values = copy.Values;
RAWValues = copy.RAWValues;
OnNewValue = copy.OnNewValue;
OnNewRAWValue = copy.OnNewRAWValue;
}
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);
}
/// <summary>
/// Clones a pin.
/// </summary>
/// <returns><c>true</c>, if pin was cloned, <c>false</c> otherwise.</returns>
/// <param name="pin">Pin.</param>
public bool ClonePin(IPin pin)
{
Console.WriteLine("Cloning: " + pin);
if ((pin as APin) != null)
{
if (AvailableAnalogPins.Length != 0)
{
APin newPin = new APin(pin as APin);
newPin.Number = AvailableAnalogPins [0].Number;
newPin.DigitalNumber = AvailableAnalogPins [0].DigitalNumber;
AddPin(newPin);
}
else
{
return(false);
}
}
else if ((pin as DPin) != null)
{
if (AvailableDigitalPins.Length != 0)
{
DPin newPin = new DPin(pin as DPin);
newPin.Number = AvailableDigitalPins [0].Number;
newPin.AnalogNumber = AvailableDigitalPins [0].AnalogNumber;
AddPin(newPin);
}
else
{
return(false);
}
}
// CheckPins ();
return(true);
}
/// <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;
}
}
}
public void APinValuesTest()
{
var pin1 = new APin ();
pin1.Value = new DateTimeValue (5, DateTime.Now);
Assert.AreEqual (5, pin1.Value.Value);
pin1.Values.Clear ();
Assert.AreEqual (double.NaN, pin1.Value.Value);
}
public APinTreeNode(APin pin, int index = -1, MeasurementCombination combination = null)
{
Pin = pin;
Combination = combination;
Index = index;
}
public APinListStoreNode(APin pin, int index = -1)
{
Pin = pin;
Index = index;
}
public APinSignalDialogTreeNode(APin pin, int index = -1)
{
Pin = pin;
Index = index;
}
private void RunAddAPinDialog (APin pin = null)
{
APinConfigDialog dialog = new APinConfigDialog (con.Configuration.AvailableAnalogPins, pin, this, this.Units);
dialog.Response += (o, args) =>
{
if (args.ResponseId == ResponseType.Apply)
{
if (pin == null)
{
con.Configuration.AddPin (dialog.Pin);
} else
{
for (int i = 0; i < con.Configuration.Pins.Count; i++)
{
if (con.Configuration.Pins [i] == pin)
{
con.Configuration.EditPin (i, dialog.Pin);
break;
}
}
}
}
};
dialog.Run ();
dialog.Destroy ();
}
public void APinvaluesTest5()
{
var pin1 = new APin ();
pin1.MeanValuesCount = 3;
pin1.Slope = .5;
pin1.Value = new DateTimeValue (4, DateTime.Now);
pin1.Value = new DateTimeValue (2, DateTime.Now);
Assert.AreEqual (double.NaN, pin1.Value.Value);
pin1.Value = new DateTimeValue (2, DateTime.Now);
Assert.AreEqual (4.0 / 3.0, pin1.Value.Value);
}
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>
/// Adds a pin.
/// </summary>
/// <returns><c>true</c>, if pin was added, <c>false</c> otherwise.</returns>
/// <param name="pin">Pin.</param>
public bool AddPin(APin pin)
{
if (!Pins.Contains (pin))
{
Pins.Add (pin);
return true;
}
return false;
}
/// <summary>
/// Setups the nodeview.
/// </summary>
private void SetupNodeView()
{
nvSignal.NodeStore = SignalStore;
nvSignal.AppendColumn (new TreeViewColumn ("Name(Pin)", new CellRendererText (), "text", 0));
nvSignal.AppendColumn (new TreeViewColumn ("Frequency", new CellRendererText (), "text", 1));
nvSignal.AppendColumn (new TreeViewColumn ("Number of mean values", new CellRendererText (), "text", 2));
nvSignal.ButtonPressEvent += new ButtonPressEventHandler (OnSignalButtonPress);
nvSignal.KeyPressEvent += new KeyPressEventHandler (OnSignalKeyPress);
nvSignal.RowActivated += (o, args) => {
var node = ((o as NodeView).NodeSelection.SelectedNode as APinSignalDialogTreeNode).Pin;
ActiveNode = node;
btnRemove.Sensitive = true;
};
}
/// <summary>
/// Gets the coresponding combination.
/// </summary>
/// <returns>The coresponding combination.</returns>
/// <param name="pin">Pin</param>
public MeasurementCombination GetCorespondingCombination(APin pin)
{
foreach (MeasurementCombination sig in MeasurementCombinations)
{
if (sig.Pins.Contains (pin))
{
return sig;
}
}
return null;
}
/// <summary>
/// Clones a pin.
/// </summary>
/// <returns><c>true</c>, if pin was cloned, <c>false</c> otherwise.</returns>
/// <param name="pin">Pin.</param>
public bool ClonePin(IPin pin)
{
Console.WriteLine ("Cloning: " + pin);
if ((pin as APin) != null)
{
if (AvailableAnalogPins.Length != 0)
{
APin newPin = new APin (pin as APin);
newPin.Number = AvailableAnalogPins [0].Number;
newPin.DigitalNumber = AvailableAnalogPins [0].DigitalNumber;
AddPin (newPin);
} else
{
return false;
}
} else if ((pin as DPin) != null)
{
if (AvailableDigitalPins.Length != 0)
{
DPin newPin = new DPin (pin as DPin);
newPin.Number = AvailableDigitalPins [0].Number;
newPin.AnalogNumber = AvailableDigitalPins [0].AnalogNumber;
AddPin (newPin);
} else
{
return false;
}
}
// CheckPins ();
return true;
}
public void APinvaluesTest2()
{
var pin1 = new APin ();
pin1.Offset = 2;
pin1.Value = new DateTimeValue (5, DateTime.Now);
Assert.AreEqual (7, pin1.Value.Value);
pin1.Offset = 0;
pin1.Slope = .5;
pin1.Value = new DateTimeValue (5, DateTime.Now);
Assert.AreEqual (2.5, pin1.Value.Value);
}
public void APinvaluesTest4()
{
var pin1 = new APin ();
pin1.MeanValuesCount = 2;
pin1.Slope = .5;
pin1.Value = new DateTimeValue (4, DateTime.Now);
pin1.Value = new DateTimeValue (2, DateTime.Now);
Assert.AreEqual (1.5, pin1.Value.Value);
}
/// <summary>
/// Initializes a new instance of the <see cref="AnalogPinConfigurationDialog.AnalogPinConfiguration"/> class.
/// </summary>
/// <param name="availablePins">Available pins.</param>
/// <param name="apin">Apin.</param>
/// <param name="parent">Parent.</param>
public APinConfigDialog(APin[] availablePins, APin apin = null, Gtk.Window parent = null, List<string> units = null)
: base("Analog Input - Dialog", parent, Gtk.DialogFlags.Modal, new object[0])
{
this.Build ();
if (apin != null) {
AvailablePins = new APin[availablePins.Length + 1];
Array.Copy (availablePins, AvailablePins, availablePins.Length);
AvailablePins [availablePins.Length] = apin;
buttonOk.Label = "Apply";
buttonOk.Image = new Image (Gtk.Stock.Apply, IconSize.Button);
} else {
AvailablePins = availablePins;
}
sbSlope.Adjustment.Lower = double.MinValue;
sbSlope.Adjustment.Upper = double.MaxValue;
sbOffset.Adjustment.Lower = double.MinValue;
sbOffset.Adjustment.Upper = double.MaxValue;
sbMeanValuesCount.Adjustment.Upper = int.MaxValue;
sbMeanValuesCount.Adjustment.Lower = 1;
for (int i = 0; i < AvailablePins.Length; i++) {
cbPin.AppendText (AvailablePins [i].DisplayNumber);
}
if (apin != null) {
Pin = new APin (apin);
} else {
if (AvailablePins.Length > 0) {
pin = AvailablePins [0];
} else {
pin = new APin ();
}
pin.PlotColor = GUIHelper.ColorHelper.GetRandomGdkColor ();
cbColor.Color = pin.PlotColor;
}
if (AvailablePins.Length > 0) {
if (apin != null) {
cbPin.Active = AvailablePins.Length - 1;
} else {
cbPin.Active = 0;
}
} else {
buttonOk.Sensitive = false;
buttonOk.TooltipText = "There are no more available pins to configure.";
}
Units = units;
ListStore store = new ListStore (typeof(string));
Units.ForEach (o => store.AppendValues (new object[]{ o }));
cbUnit.Model = store;
if (!string.IsNullOrEmpty (pin.Unit)) {
if (Units.Contains (pin.Unit)) {
cbUnit.Active = Array.IndexOf (Units.ToArray (), pin.Unit);
} else {
store.AppendValues (new string[]{ pin.Unit });
cbUnit.Active = Units.Count;
}
} else {
cbUnit.Active = Array.IndexOf (Units.ToArray (), "V");
}
BindEvents ();
}
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);
}
