public override void Execute(Blocks.EventDescription e)
{
for (int i = 0; i < outputs; i++)
{
OutputNodes[i].Object = InputNodes[0].Object;
}
}
public override void Execute(Blocks.EventDescription e)
{
var streamIn = InputNodes[0].Object;
if (Utils.IsSignal(streamIn))
{
streamIn = Utils.AsSignal(streamIn).Samples;
}
if (Utils.IsArrayOf <double>(streamIn))
{
double[] DataStream = (double[])streamIn;
double[] data = new double[DataStream.Length];
switch (LineCoding)
{
case LineCodings.BipolarNRZ:
Coding_BipolarNRZ(DataStream, ref data, (Operation == LineCodingOps.Encode ? false : true));
break;
case LineCodings.None:
default:
DataStream.CopyTo(data, 0);
break;
}
OutputNodes[0].Object = data;
}
}
public override void Execute(Blocks.EventDescription e)
{
if (InputNodes[0].ConnectingNode != null)
{
var obj = InputNodes[0].Object;
if (obj != null)
{
double[] vals = new double[1];
if (Utils.IsSignal(obj))
{
OpenSignalLib.Sources.Signal sig = Utils.AsSignal(obj);
vals = sig.Samples;
}
else if (Utils.IsArrayOf <double>(obj))
{
vals = (double[])obj;
}
else if (Utils.IsArrayOf <float>(obj))
{
vals = OpenSignalLib.Operations.Misc.ToArray((float[])obj);
}
else if (obj.ToString().IsNumeric())
{
vals[0] = double.Parse(obj.ToString());
}
else
{
throw new InvalidCastException("invalid input type : " + obj.GetType().Name);
}
OutputNodes[0].Object = process(vals);
}
}
}
public override void Execute(Blocks.EventDescription e)
{
var input1 = InputNodes[0].Object;
var input2 = InputNodes[1].Object;
if (Utils.IsSignal(input1))
{
input1 = Utils.AsSignal(input1).Samples;
}
if (Utils.IsSignal(input2))
{
input2 = Utils.AsSignal(input2).Samples;
}
if (Utils.IsArrayOf <double>(input1) && Utils.IsArrayOf <double>(input2))
{
double[] actual = (double[])input1;
double[] received = (double[])input2;
if ((actual.Length != received.Length))
{
throw new Exception("Transmitted (tx) and Received(rx) sequences are of different length");
}
double total_errors = 0;
for (int i = 0; i < actual.Length; i++)
{
if (actual[i] != received[i])
{
total_errors++;
}
}
OutputNodes[0].Object = (total_errors) / (double)actual.Length;
}
}
public override void Execute(Blocks.EventDescription e)
{
if (InputNodes[0].ConnectingNode != null)
{
var obj = InputNodes[0].Object;
if (Utils.IsSignal(obj))
{
var sig = Utils.AsSignal(obj);
double[] samples = sig.Samples;
bgWorker = new BackgroundWorker();
bgWorker.DoWork += delegate(object sender, DoWorkEventArgs ex) {
if (aOut == null)
{
aOut = new AnalogOut(samples, (int)sig.SamplingRate);
aOut.AutoPlayOnUpdate = true;
aOut.Play();
}
else
{
aOut.Update(samples);
}
};
bgWorker.RunWorkerAsync();
System.Threading.Thread.Sleep(100);
while (aOut.IsPlaying())
{
System.Threading.Thread.Sleep(100);
}
aOut.Stop();
}
}
}
public override void Execute(Blocks.EventDescription e)
{
var input = InputNodes[0].Object;
if (Utils.IsSignal(input))
{
input = Utils.AsSignal(input).Samples;
}
if (Utils.IsArrayOf <double>(input))
{
if (ConversionFrom == InputTypes.Symbols)
{
double[] syms = (double[])InputNodes[0].Object;
double[] bits = new double[(int)(syms.Length * BitsPerSymbol)];
int j = 0;
for (int i = 0; i < syms.Length; i++)
{
string res = Convert.ToString((int)syms[i], 2);
foreach (var item in res)
{
bits[j++] = (item == '0') ? 0 : 1;
}
}
OutputNodes[0].Object = bits;
}
else
{
double[] bits = (double[])input;
double[] syms = ConvertToSymbols(bits);
OutputNodes[0].Object = syms;
}
}
}
public override void Execute(Blocks.EventDescription e)
{
var sel = InputNodes[2].Object;
var in1 = InputNodes[0].Object;
var in2 = InputNodes[1].Object;
if (Utils.IsSignal(sel) && Utils.IsSignal(in1) && Utils.IsSignal(in2))
{
OpenSignalLib.Sources.Signal s1 = Utils.AsSignal(in1);
OpenSignalLib.Sources.Signal s2 = Utils.AsSignal(in2);
OpenSignalLib.Sources.Signal ctrl = Utils.AsSignal(sel);
if (s1.Length == s2.Length && s1.Length == ctrl.Length)
{
}
}
else
{
if (sel == null || false == (bool)sel)
{
OutputNodes[0].Object = InputNodes[1].Object;
}
else
{
OutputNodes[0].Object = InputNodes[0].Object;
}
}
}
public override void Execute(Blocks.EventDescription e)
{
if (InputNodes[0].ConnectingNode != null)
{
if (confi == null && !System.IO.File.Exists(FileName))
{
throw new Exception(this.ID + " <" + this.Name + "> :: File '" + FileName + "' does not exist or is invalid");
}
if (Utils.IsSignal(InputNodes[0].Object))
{
OpenSignalLib.Filters.IIRFilter iir;
if (confi == null) // use co-efficients file
{
var coeffs = ReadCoefficientFile(FileName);
iir = new OpenSignalLib.Filters.IIRFilter(coeffs.Keys.ToArray(),
coeffs.Values.ToArray());
}
else // use desinger specifications
{
iir = OpenSignalLib.Filters.FilterDesign.DesignIIR(confi.FilterType, confi.BandType, confi.n,
confi.fc, confi.f0, confi.Ap, confi.As);
}
OpenSignalLib.Sources.Signal sig = Utils.AsSignal(InputNodes[0].Object);
float[] filtered = OpenSignalLib.Filters.FilterDesign.ApplyFilter(iir,
OpenSignalLib.Operations.Misc.ToArray(sig.Samples));
OutputNodes[0].Object = new OpenSignalLib.Sources.Signal(sig.SamplingRate,
OpenSignalLib.Operations.Misc.ToArray(filtered));
}
}
}
public override void Execute(Blocks.EventDescription e)
{
if (InputNodes[0].ConnectingNode != null)
{
var obj = InputNodes[0].Object;
double[] x, y;
if (obj != null)
{
if (Utils.IsArrayOf <double>(obj))
{
dynamic vals = obj;
y = (double[])vals;
x = new double[y.Length];
for (int i = 0; i < y.Length; i++)
{
x[i] = (double)i;
}
var pltctrl = _createPlot(x, y);
}
else if (Utils.IsSignal(obj))
{
OpenSignalLib.Sources.Signal sig = Utils.AsSignal(obj);
y = sig.Samples;
x = new double[y.Length];
for (int i = 0; i < x.Length; i++)
{
x[i] = i * (1.0 / sig.SamplingRate);
}
var pltctrl = _createPlot(x, y);
}
else if (obj.GetType() == typeof(Dictionary <double, double>))
{
Dictionary <double, double> vals = (Dictionary <double, double>)obj;
x = vals.Keys.ToArray();
y = vals.Values.ToArray();
var pltctrl = _createPlot(x, y);
Logger.D("Dictionary");
}
else if (Utils.IsArrayOf <Complex>(obj))
{
Complex[] vals = (Complex[])obj;
x = new double[vals.Length];
y = new double[vals.Length];
for (int i = 0; i < vals.Length; i++)
{
x[i] = vals[i].Re;
y[i] = vals[i].Im;
}
var pltctrl = _createPlot(x, y);
pltctrl.Curve.Line.IsVisible = false;
pltctrl.Curve.Symbol.Type = ZedGraph.SymbolType.Circle;
}
else
{
throw new Exception("invalid input type : " + obj.GetType().Name);
}
}
}
}
public override void Execute(Blocks.EventDescription e)
{
float fs = float.Parse(Utils.Parse(SamplingRate, "SamplingRate").ToString());
OpenSignalLib.Sources.Signal s = new OpenSignalLib.Sources.SignalGenerator(
(OpenSignalLib.Sources.SignalType) this.NoiseType, 100, 0, fs, 1, (int)fs);
OutputNodes[0].Object = s;
}
public override void Execute(Blocks.EventDescription e)
{
if (InputNodes[0].ConnectingNode != null)
{
if (Utils.IsSignal(InputNodes[0].Object))
{
var spectrum = OpenSignalLib.Transforms.Fourier.fspectrum(Utils.AsSignal(InputNodes[0].Object));
OutputNodes[0].Object = spectrum;
}
}
}
public override void Execute(Blocks.EventDescription e)
{
OpenSignalLib.Sources.Signal s;
if (GenerateSymbols)
{
s = new OpenSignalLib.Sources.Signal((float)1, GetLineCodedStream());
}
else
{
s = new OpenSignalLib.Sources.Signal((float)this.SampleRate, GetLineCodedStream());
}
OutputNodes[0].Object = s;
}
public override void Execute(Blocks.EventDescription e)
{
if (Type == OpenSignalLib.Sources.SignalType.UserDefined)
{
throw new InvalidOperationException("UserDefined Signal Type is invalid in this context");
}
OpenSignalLib.Sources.Signal sig = new OpenSignalLib.Sources.SignalGenerator
(Type, Frequency, Phase, SampleRate, Amplitude);
for (int i = 0; i < OutputNodes.Count; i++)
{
OutputNodes[i].Object = sig;
}
}
public override void Execute(Blocks.EventDescription e)
{
IronPython.Runtime.PythonFunction fun = (IronPython.Runtime.PythonFunction)AppGlobals.PyVarGetFunc(pf);
if (fun != null)
{
object[] args = new object[InputNodes.Count];
for (int i = 0; i < InputNodes.Count; i++)
{
args[i] = InputNodes[i].Object;
}
object result = AppGlobals.InvokeFunction(fun, args);
OutputNodes[0].Object = result;
}
}
public override void Execute(Blocks.EventDescription e)
{
if (InputNodes[0].ConnectingNode != null)
{
var obj = InputNodes[0].Object;
if (Utils.IsArrayOf <OpenSignalLib.ComplexTypes.Complex>(obj))
{
OpenSignalLib.ComplexTypes.Complex[] fft = (OpenSignalLib.ComplexTypes.Complex[])obj;
var vals = OpenSignalLib.Transforms.Fourier.iFFT(fft,
int.Parse(AppGlobals.PyExecuteExpr(N).ToString()));
OutputNodes[0].Object = Utils.GetAbsolute(vals);
}
}
}
public override void Execute(Blocks.EventDescription e)
{
OpenSignalLib.Sources.Signal sig = null;
foreach (var item in this.Frequencies)
{
float f = float.Parse(item);
if (sig == null)
{
sig = new OpenSignalLib.Sources.Sinusoidal(f, 0.0f, (float)this.SampleRate, 1, this.Length);
}
else
{
sig += new OpenSignalLib.Sources.Sinusoidal(f, 0.0f, (float)this.SampleRate, 1, this.Length);
}
}
OutputNodes[0].Object = sig;
}
public override void Execute(Blocks.EventDescription e)
{
if (InputNodes[0].ConnectingNode != null)
{
var obj = InputNodes[0].Object;
if (Utils.IsSignal(obj))
{
OpenSignalLib.Sources.Signal sig = Utils.AsSignal(obj);
double power = 0.0;
for (int i = 0; i < sig.Samples.Length; i++)
{
power += (sig.Samples[i] * sig.Samples[i]);
}
power = (1.0 / sig.Samples.Length) * power;
OutputNodes[0].Object = power;
}
}
}
public override void Execute(Blocks.EventDescription e)
{
if (InputNodes[0].ConnectingNode != null)
{
if (!System.IO.File.Exists(FileName))
{
throw new Exception(this.ID + " <" + this.Name + "> :: File '" + FileName + "' does not exist or is invalid");
}
if (Utils.IsSignal(InputNodes[0].Object))
{
OpenSignalLib.Filters.FIRFilter fir = new OpenSignalLib.Filters.FIRFilter(ReadCoefficientFile(FileName));
OpenSignalLib.Sources.Signal sig = Utils.AsSignal(InputNodes[0].Object);
float[] filtered = OpenSignalLib.Filters.FilterDesign.ApplyFilter(fir,
OpenSignalLib.Operations.Misc.ToArray(sig.Samples));
OutputNodes[0].Object = new OpenSignalLib.Sources.Signal(sig.SamplingRate,
OpenSignalLib.Operations.Misc.ToArray(filtered));
}
}
}
public override void Execute(Blocks.EventDescription e)
{
if (InputNodes[0].ConnectingNode != null)
{
double[] x, y;
var obj = InputNodes[0].Object;
if (Utils.IsSignal(obj))
{
OpenSignalLib.Sources.Signal s = Utils.AsSignal(obj);
Logger.D(s.SamplingRate.ToString());
int n = int.Parse(AppGlobals.PyExecuteExpr(N).ToString());
var spectrum = OpenSignalLib.Transforms.Fourier.fspectrum(s, n);
x = spectrum.Keys.ToArray();
y = spectrum.Values.ToArray();
}
else
{
throw new Exception("invalid input type : " + obj.GetType().Name);
}
if (!Hold || (plotControl.Window == null || plotControl.Window.IsDisposed))
{
_createPlot(x, y);
}
if (Hold)
{
plotControl.Curve.Clear();
for (int i = 0; i < x.Length; i++)
{
if (Scale == Scales.dB_Scale)
{
plotControl.Curve.AddPoint(x[i], 10 * Math.Log10(y[i]));
}
else
{
plotControl.Curve.AddPoint(x[i], y[i]);
}
}
plotControl.Control.AxisChange();
plotControl.Control.Invalidate();
}
}
}
public override void Execute(Blocks.EventDescription e)
{
if (InputNodes[0].ConnectingNode != null)
{
var obj = InputNodes[0].Object;
if (obj != null)
{
if (Utils.IsSignal(obj))
{
OpenSignalLib.Sources.Signal sig = Utils.AsSignal(obj);
var fout = new System.IO.StreamWriter(FileName);
for (int i = 0; i < sig.Samples.Length; i++)
{
fout.WriteLine(sig.Samples[i].ToString());
}
fout.Close();
}
}
}
}
public override void Execute(Blocks.EventDescription e)
{
//t0=t(1);
//T=t1-t0;
//k=(f1-f0)/T;
//x=cos(2*pi*(k/2*t+f0).*t+phase);
double t0 = 0;
double T = t1;
double k = (f1 - f0) / T;
OpenSignalLib.Sources.Signal sig = new OpenSignalLib.Sources.Signal(this.SamplingRate, new double[Length]);
double t = 0;
for (int i = 0; i < this.Length; i++)
{
t = i * (1.0 / SamplingRate);
sig.Samples[i] = Math.Cos(2 * Math.PI * ((k / 2 * t) + f0) * t + Phase);
}
OutputNodes[0].Object = sig;
}
public override void Execute(Blocks.EventDescription e)
{
if (InputNodes[0].ConnectingNode != null)
{
double[] values = new double[0];
if (Utils.IsSignal(InputNodes[0].Object))
{
values = Utils.AsSignal(InputNodes[0].Object).Samples;
}
var vals = OpenSignalLib.Transforms.Fourier.FFT(values,
int.Parse(AppGlobals.PyExecuteExpr(N).ToString()));
if (OutputAbsoluteValues)
{
double[] vec = Utils.GetAbsolute(vals);
OutputNodes[0].Object = vec;
}
else
{
OutputNodes[0].Object = vals;
}
}
}
public override void Execute(Blocks.EventDescription e)
{
throw new NotImplementedException();
}
public override void Execute(Blocks.EventDescription e)
{
Signal sig = ReadSignalFile(FilePath);
OutputNodes[0].Object = sig;
}
public override void Execute(Blocks.EventDescription e)
{
OutputNodes[0].Object = AppGlobals.PyExecuteExpr(Value);
}
public override void Execute(Blocks.EventDescription e)
{
if (InputNodes[0].ConnectingNode != null)
{
var obj = InputNodes[0].Object;
if (Utils.IsSignal(obj))
{
obj = Utils.AsSignal(obj).Samples;
}
if (obj != null)
{
if (Utils.IsArrayOf <double>(obj) && Operation == Operations.Modulate)
{
double[] vars = ((double[])obj);
int[] symbols = new int[vars.Length];
for (int i = 0; i < symbols.Length; i++)
{
symbols[i] = (int)vars[i];
}
var m = new OpenSignalLib.Modems.Modem(this.Scheme);
OutputNodes[0].Object = m.Modulate(symbols);
}
else if (Utils.IsArrayOf <OpenSignalLib.ComplexTypes.Complex>(obj) || Operation == Operations.Demodulate)
{
var m = new OpenSignalLib.Modems.Modem(this.Scheme);
OpenSignalLib.ComplexTypes.Complex[] vals = (OpenSignalLib.ComplexTypes.Complex[])obj;
int[] _tmp = m.Demodulate(vals);
double[] syms = new double[_tmp.Length];
for (int i = 0; i < _tmp.Length; i++)
{
syms[i] = (double)_tmp[i];
}
if (OutputFormat == OutFormat.Symbols)
{
OutputNodes[0].Object = syms;
}
else
{
double[] bits = new double[(int)(syms.Length * Math.Log(m.ConstellationSize) / Math.Log(2))];
int j = 0;
for (int i = 0; i < syms.Length; i++)
{
string res = Convert.ToString((int)syms[i], 2);
while (res.Length < m.BitsPerSymbol)
{
res = "0" + res;
}
foreach (var item in res)
{
bits[j++] = (item == '0') ? 0 : 1;
}
}
OutputNodes[0].Object = bits;
}
}
else
{
throw new Exception("invalid input type: " + obj.GetType().Name);
}
}
}
}
