void ProgressUpdated(RunState state, double frequency, Waveform w, double amplitude, TimeSpan timeleft)
{
if (state == RunState.Error)
{
Pause("Error - check hardware");
}
if (!double.IsNaN(frequency))
{
frequencyLabel.Text = $"{frequency:0.00} Hz";
}
etaLabel.Text = $"{timeleft.Hours:00}:{timeleft.Minutes:00}:{timeleft.Seconds:00}";
if (!double.IsNaN(amplitude))
{
amplitudeLabel.Text = $"{amplitude:0.00} V";
}
if (w != Waveform.Default)
{
waveformLabel.Text = w.WaveformToString();
}
if (state == RunState.Completed)
{
if (options.runInLoop)
{
runner.Start(runnable, channel, options);
}
else
{
Finished();
onFinished();
}
}
}
public static double Oscillate(Waveform waveform, double time, float hz)
{
return(settings.Evaluate(waveform, time * hz));
//Old procedural waveforms
//switch (waveform)
//{
// case Waveform.Triangle:
// return Tri(time * hz);
// case Waveform.TiltedTriangle:
// return TiltedTri(time * hz);
// case Waveform.Sawtooth:
// return Saw(time * hz);
// case Waveform.Square:
// return Square(time * hz);
// case Waveform.Pulse:
// return Pulse(time * hz);
// case Waveform.Organ:
// return Organ(time * hz);
// case Waveform.Noise:
// return Noise(time * hz);
// case Waveform.Phaser:
// return Phaser(time * hz);
//}
//return 0;
}
private void copyToCommonWaveformsToolStripMenuItem_Click(object sender, EventArgs e)
{
Waveform copy = new Waveform(currentWaveform);
Storage.sequenceData.CommonWaveforms.Add(copy);
WordGenerator.MainClientForm.instance.commonWaveformEditor.setCommonWaveforms(Storage.sequenceData.CommonWaveforms);
}
public AnalogGroupChannelData(AnalogGroupChannelData copyMe)
{
//copy constructor, which duplicates the copyMe object;
this.myWaveform = new Waveform(copyMe.myWaveform);
this.channelEnabled = copyMe.ChannelEnabled;
this.channelWaveformIsCommon = copyMe.ChannelWaveformIsCommon;
}
static void DecodeStreamAdpcm(aBinaryReader reader, aBinaryWriter writer, int sampleCount)
{
var left = new short[16];
int left_last = 0, left_penult = 0;
var right = new short[16];
int right_last = 0, right_penult = 0;
for (var i = 0; i < sampleCount; i += 16)
{
Waveform.Adpcm4toPcm16(reader.Read8s(9), left, ref left_last, ref left_penult);
Waveform.Adpcm4toPcm16(reader.Read8s(9), right, ref right_last, ref right_penult);
for (var j = 0; j < 16 && (i + j) < sampleCount; ++j)
{
writer.WriteS16(left[j]);
writer.WriteS16(right[j]);
}
if ((i % cMessageInterval) == 0 || (i + 16) >= sampleCount)
{
mareep.WriteMessage("\rSamples encoded: {0}/{1}", System.Math.Min((i + 16), sampleCount), sampleCount);
}
}
}
public AcquisitionEngine(IDataSource source)
{
samplesOverflowSink = new List <float>();
overviewWfLastCapture = DateTime.Now;
overviewWf = new Waveform(1, 6000000);
TriggerSources = new List <ITrigger>();
TriggerSources.Add(new FreeRunning());
TriggerSources.Add(new Edge());
Trigger = new Edge(); // TODO: Temporary trigger
Source = source;
Source.Data += ProcessWaveform;
Source.Data += Source_Data;
Source.HighresVoltage += Source_HighresVoltage;
Source.Connect(null);
var dummyCfg = new NetStreamConfiguration();
dummyCfg.AdcSpeed = 0;
dummyCfg.AfeGain = 0;
dummyCfg.UseFastAdc = false;
Source.Configure(dummyCfg);
}
/// <summary>
/// Initializes a new instance of the <see cref="HBM0OhmJS001Standard"/> class
/// </summary>
/// <param name="compensateForNoise">A value indicating whether to compensate for noise or not</param>
/// <param name="compensateForNoiseCutoffTime">The time to stop measuring for noise from the beginning of the waveform</param>
/// <param name="riseTimeStartPercent">Rise Time starting percentage (Default: 90%)</param>
/// <param name="riseTimeEndPercent">Rise Time ending percentage (Default: 10%)</param>
/// <param name="peakCurrentDerivationOffsetTime">The amount of time after Tmax to interpolate Ips (see 5.2.3.3.1) in seconds. Suggested is 40ns</param>
/// <param name="findDoublePeak">A value indicating whether to look for a second peak that is slightly lower than the max peak, because some testers generate this type of peak</param>
/// <param name="doublePeakPercentIncrease">The percent increase to look for when looking for a second peak.</param>
/// <param name="doublePeakLowerPercentCutoff">The lower percent cutoff below which double-peaks will not be searched for</param>
/// <param name="waveform">The HBM 0-Ohm waveform to provide calculations on</param>
/// <param name="signedVoltage">The signed voltage</param>
public HBM0OhmJS001Standard(
bool compensateForNoise,
double compensateForNoiseCutoffTime,
double riseTimeStartPercent,
double riseTimeEndPercent,
double peakCurrentDerivationOffsetTime,
bool findDoublePeak,
double doublePeakPercentIncrease,
double doublePeakLowerPercentCutoff,
Waveform waveform,
double signedVoltage)
: base(waveform, signedVoltage)
{
this.compensateForNoise = compensateForNoise;
this.compensateForNoiseCutoffTime = compensateForNoiseCutoffTime;
this.peakCurrentDerivationOffsetTime = peakCurrentDerivationOffsetTime;
this.findDoublePeak = findDoublePeak;
this.doublePeakPercentIncrease = doublePeakPercentIncrease;
this.doublePeakLowerPercentCutoff = doublePeakLowerPercentCutoff;
this.CalculateIpsMaxDataPoint();
this.CalculatePeakCurrent();
this.CalculateRiseTime(riseTimeStartPercent, riseTimeEndPercent);
this.CalculateDecayTime();
this.CalculateRing();
}
public AcquisitionEngine(IDataSource source)
{
samplesOverflowSink = new List<float>();
overviewWfLastCapture = DateTime.Now;
overviewWf = new Waveform(1, 6000000);
TriggerSources = new List<ITrigger>();
TriggerSources.Add(new FreeRunning());
TriggerSources.Add(new Edge());
Trigger = new Edge(); // TODO: Temporary trigger
Source = source;
Source.Data += ProcessWaveform;
Source.Data += Source_Data;
Source.HighresVoltage += Source_HighresVoltage;
Source.Connect(null);
var dummyCfg = new NetStreamConfiguration();
dummyCfg.AdcSpeed = 0;
dummyCfg.AfeGain = 0;
dummyCfg.UseFastAdc = false;
Source.Configure(dummyCfg);
}
public IHttpActionResult PutWaveform(int id, Waveform waveform)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != waveform.WaveformID)
{
return(BadRequest());
}
db.Entry(waveform).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!WaveformExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
/// <summary>
/// Normalisiert eine Waveform in den Bereich zwischen 0 und 1.
/// </summary>
/// <param name="waveform">Die originale Waveform.</param>
/// <returns>Die normalisierte Waveform.</returns>
public static Waveform Normalize(Waveform waveform)
{
List<Waveform> waveforms = new List<Waveform>();
waveforms.Add(waveform);
NormalizeMultiple(ref waveforms);
return waveforms[0];
}
static void Main(string[] args)
{
Program p = new Program();
Waveform waveform = new Waveform();
p.DeleteEntity <Waveform>(waveform);
}
void Serialize(string filename){
// normalizes the data to the {0.0-1.0f} interval and saves as xml
Waveform w = new Waveform();
w.name = filename;
w.cycles=1;
w.signal = signal;
w.mode=filename;
w.normalRate = normal;
w.samples = dataPoints.Count;
float scale = dataMax-dataMin;
if ( scale == 0.0f )
scale = 1.0f;
w.data = new float[dataPoints.Count];
for (int i=0;i< dataPoints.Count;i++){
w.data[i]= (dataPoints[i].point-dataMin)/scale;
}
XmlSerializer serializer = new XmlSerializer(typeof(Waveform));
FileStream stream = new FileStream(filename + ".xml", FileMode.Create);
serializer.Serialize(stream, w);
stream.Close();
}
/// <summary>
/// Returns "oscillator" value as function of phase. Result between -1 and 1.
/// </summary>
/// <param name="CurrentOption">WaveForm.</param>
/// <param name="phase">The phase angle of the oscillator. Between 0 and 2PI. If not, it will be.</param>
/// <param name="currentsamplevalue"></param>
/// <param name="p">0 to 2. PWM like stuff. Except it works for sine and triangle too. 1 is normal waveform.</param>
static public void Waveformswitcher(Waveform CurrentOption, double phase, ref double currentsamplevalue, double p = 1)
{
double correctedphase = Z_nthCommon.Phase.Correction(phase);
switch (CurrentOption)
{
case Waveform.Sine:
currentsamplevalue += Z_nthCommon.Phase.Sine(correctedphase, p);
break;
case Waveform.Saw:
currentsamplevalue += Z_nthCommon.Phase.Saw(correctedphase, p);
break;
case Waveform.Square:
currentsamplevalue += Z_nthCommon.Phase.Square(correctedphase, p);
break;
case Waveform.Triangle:
currentsamplevalue += Z_nthCommon.Phase.Triangle(correctedphase, p);
break;
default:
break;
}
}
private void FireTriggeredWaveform(Waveform f)
{
if (TriggeredWaveform != null)
{
TriggeredWaveform(f);
}
}
//main logic
private static void TimerTick(object sender, EventArgs e)
{
//initialize after elements have loaded
if (!m_HasInit)
{
//init spectrogram
int spectrogramWidth = (int)Instance.SpectrogramPanel.ActualWidth * 2;
int spectrogramHeight = (int)Instance.SpectrogramGrid.ActualHeight * 2;
m_Spectrogram = new Spectrogram(spectrogramWidth, spectrogramHeight, m_SpectrogramMultiplier);
int waveformWidth = (int)Instance.WaveformPanel.ActualWidth * 2;
int waveformHeight = (int)Instance.WaveformPanel.ActualHeight * 2;
m_Waveform = new Waveform(waveformWidth, waveformHeight, m_WaveformMultiplier);
Mixer.SetUnusedChannels();
m_HasInit = true;
}
Analyzer.ProcessBarValues();
Mixer.ProcessLevels();
Instance.SpectrogramBitmap.Fill = m_Spectrogram.CreateBitmap();
Instance.WaveformBitmap.Fill = m_Waveform.CreateBitmap();
}
/// <inheritdoc/>
public override IndependentSourceParameters Clone()
{
var clone = base.Clone();
clone.Waveform = Waveform?.Clone();
return(clone);
}
public void HBMJS001500OhmNegativeTest()
{
Waveform waveform = PublicStandardTestExtensions.ParseWaveformFromString(Properties.Resources.HBM_500Ohm_Neg_4000V);
HBM500OhmJS001Standard hbm500OhmJS001Standard = new HBM500OhmJS001Standard(waveform, -4000);
// Assert that Peak Current value is within 1mA of expected
Assert.AreEqual(-1.709, hbm500OhmJS001Standard.PeakCurrentValue, 0.001);
// Assert that Peak Current min/max are within 1mA of expected
Assert.AreEqual(-1.5, hbm500OhmJS001Standard.PeakCurrentAllowedMinimum, 0.001);
Assert.AreEqual(-2.2, hbm500OhmJS001Standard.PeakCurrentAllowedMaximum, 0.001);
// Assert that Peak Current is passing
Assert.IsTrue(hbm500OhmJS001Standard.PeakCurrentIsPassing);
// Assert that Rise Time is within 10ps of expected
Assert.AreEqual(0.00000002292, hbm500OhmJS001Standard.RiseTimeValue, 0.000000000010);
// Assert that Rise Time min/max are within 10ps of expected
Assert.AreEqual(0.000000005, hbm500OhmJS001Standard.RiseTimeAllowedMinimum, 0.000000000010);
Assert.AreEqual(0.000000025, hbm500OhmJS001Standard.RiseTimeAllowedMaximum, 0.000000000010);
// Assert that Rise Time is passing
Assert.IsTrue(hbm500OhmJS001Standard.RiseTimeIsPassing);
}
public Command(ICommand cmd, double freq, Waveform w, double amplitude, TimeSpan t)
{
Cmd = cmd;
Frequency = freq;
Remaining = t;
Waveform = w;
Amplitude = amplitude;
}
/// <summary>
/// Creates an oscillator.
/// </summary>
/// <param name="waveform">The type of wave the oscillator will follow.</param>
/// <param name="speed">How fast the oscillator with oscillate.</param>
/// <param name="magnitude">The min/max value the oscillator will return.</param>
public Oscillator(Waveform waveform, float speed = 1f, double magnitude = 1f)
{
_waveform = waveform;
_speed = speed;
_magnitude = magnitude;
_last_frame = DateTime.UtcNow;
}
public WaveformGraph(Waveform waveform, WaveformEditor waveformEditor, bool waveformEditable)
: this()
{
// TODO: Write this function.
setWaveform(waveform);
setWaveformEditor(waveformEditor);
this.editable = waveformEditable;
}
/// <summary>
/// Initializes a new instance of the <see cref="CDMJS002Standard"/> class
/// </summary>
/// <param name="waveform">The CDM waveform to provide calculations on</param>
/// <param name="signedVoltage">The signed voltage</param>
/// <param name="isLargeTarget">A value indicating whether the CDM target is the Large target or not (small if not)</param>
/// <param name="oscilloscopeIsHighBandwidth">A value indicating whether the oscilloscope used is high bandwidth or not</param>
public CDMJS002Standard(
Waveform waveform,
double signedVoltage,
bool isLargeTarget,
bool oscilloscopeIsHighBandwidth)
: this(waveform, signedVoltage, isLargeTarget, oscilloscopeIsHighBandwidth, 0.1, 0.9, 0)
{
}
/// <summary>
/// Hängt zwei Waveforms aneinander an.
/// </summary>
/// <param name="a">Die erste Waveform.</param>
/// <param name="b">Die zweite Waveform.</param>
/// <returns>Die verbundene Waveform (a+b).</returns>
public static Waveform Concatenate(Waveform a, Waveform b)
{
for (int i = b.First; i <= b.Last; i++)
{
a.Add(b[i]);
}
return a;
}
public void SetWaveform(int channel, Waveform value)
{
CheckChannel(channel);
// !! Set
int wf = 0;
Send(Command.set_waveform_1, channel, wf);
}
public static Waveform GetRandomWaveform()
{
Array values = Enum.GetValues(typeof(Waveform));
System.Random random = new System.Random();
Waveform randomWave = (Waveform)values.GetValue(random.Next(values.Length));
return(randomWave);
}
private void _DisposePreviewWaveform()
{
if (m_waveform != null)
{
m_waveform.Paint += PreviewWaveform_Paint;
m_waveform.Dispose();
m_waveform = null;
}
}
public Waveform GetEEGWaveform(Electrode electrode)
{
Waveform Waveform = new Waveform(0, sampleRate);
foreach (EEGSample sample in goodSamples)
{
Waveform.Add(sample.eegValues[electrode]);
}
return Waveform;
}
/// <summary>
/// Add Waveform to the chart.
/// </summary>
///
/// <param name="name">Waveform name.</param>
/// <param name="color">Waveform color.</param>
/// <param name="width">Waveform width.</param>
/// <param name="updateYRange">Specifies if <see cref="RangeY"/> should be updated.</param>
///
/// <remarks><para>Adds new empty waveform to the collection of waves. To update this
/// wave the <see cref="UpdateWaveform(string, float[])"/> method should be used.</para>
/// </remarks>
///
/// <remarks><para>Adds new empty data series to the collection of data series.</para>
///
/// <para>The <b>updateYRange</b> parameter specifies if the waveform may affect displayable
/// Y range. If the value is set to false, then displayable Y range is not updated, but used the
/// range, which was specified by user (see <see cref="RangeY"/> property). In the case if the
/// value is set to true, the displayable Y range is recalculated to fully fit the new data
/// series.</para>
/// </remarks>
///
public void AddWaveform(string name, Color color, int width, bool updateYRange)
{
Waveform series = new Waveform();
series.color = color;
series.width = width;
series.updateYRange = updateYRange;
waveTable.Add(name, series);
}
/// <summary>
/// Initializes a new instance of the <see cref="HBM500OhmJS001Standard"/> class
/// </summary>
/// <param name="waveform">The HBM 500-Ohm waveform to provide calculations on</param>
/// <param name="signedVoltage">The signed voltage</param>
/// <param name="riseTimeStartPercent">Rise Time starting percentage (Default: 90%)</param>
/// <param name="riseTimeEndPercent">Rise Time ending percentage (Default: 10%)</param>
public HBM500OhmJS001Standard(
Waveform waveform,
double signedVoltage,
double riseTimeStartPercent,
double riseTimeEndPercent)
: base(waveform, signedVoltage)
{
this.CalculatePeakCurrent();
this.CalculateRiseTime(riseTimeStartPercent, riseTimeEndPercent);
}
static void Main()
{
string resourceName = "VST2";
string filePath = Path.GetFullPath(@"Support Files\80211a_20M_48Mbps.tdms");
GenerationType genType = GenerationType.Continuous;
NIRfsg nIRfsg = new NIRfsg(resourceName, false, false);
InstrumentConfiguration instrConfig = InstrumentConfiguration.GetDefault();
instrConfig.CarrierFrequency_Hz = 2e9;
ConfigureInstrument(nIRfsg, instrConfig);
Waveform waveform = LoadWaveformFromTDMS(filePath);
DownloadWaveform(nIRfsg, waveform);
switch (genType)
{
// For continous generation, we can simply call this function to begin the generation
case GenerationType.Continuous:
ConfigureContinuousGeneration(nIRfsg, waveform);
break;
// For bursted generation, we need to configure the duty cycle and PA control
case GenerationType.Bursted:
WaveformTimingConfiguration dynamicConfig = new WaveformTimingConfiguration
{
DutyCycle_Percent = 20,
PreBurstTime_s = 500e-9,
PostBurstTime_s = 500e-9,
BurstStartTriggerExport = "PXI_Trig0"
};
PAENConfiguration paenConfig = new PAENConfiguration
{
PAEnableMode = PAENMode.Dynamic,
PAEnableTriggerExportTerminal = "PFI0",
PAEnableTriggerMode = RfsgMarkerEventOutputBehaviour.Toggle,
CommandEnableTime_s = 0,
CommandDisableTime_s = 0,
};
ConfigureBurstedGeneration(nIRfsg, waveform, dynamicConfig, paenConfig, out _, out _);
break;
}
nIRfsg.Initiate();
Console.WriteLine("Generation has now begun. Press any key to abort generation and close the example.");
Console.ReadKey();
AbortGeneration(nIRfsg);
CloseInstrument(nIRfsg);
}
/// <summary>
/// Gets the value of the specified analog channel at the end of the timestep. Returns 0 if value is unspecified. Note
/// that this is not necessarily the true sequence-specified value, as this method does not take into account
/// analog groups which have been continued from previous timesteps.
/// </summary>
/// <param name="analogChannelID"></param>
/// <returns></returns>
public double getEndAnalogValue(int analogChannelID, List <Variable> existingVariables, List <Waveform> existingCommonWaveforms)
{
Waveform wf = getChannelWaveform(analogChannelID);
if (wf == null)
{
return(0);
}
return(wf.getValueAtTime(this.stepDuration.getBaseValue(), existingVariables, existingCommonWaveforms));
}
public IHttpActionResult GetWaveform(int id)
{
Waveform waveform = db.Waveforms.Find(id);
if (waveform == null)
{
return(NotFound());
}
return(Ok(waveform));
}
/// <summary>
/// Calculates the Undershoot related values
/// </summary>
/// <param name="undershootMaxTimeFWHMMultiplier">(Optional) The multiplier of the FWHM time to determine how long after the peak current time to search for undershoot (Default: 2.5x)</param>
private void CalculateUndershoot(double undershootMaxTimeFWHMMultiplier = 2.5)
{
if (undershootMaxTimeFWHMMultiplier <= 0)
{
throw new ArgumentOutOfRangeException("The Undershoot Max Time multiplier cannot be less than or equal to 0");
}
// Determine how much time after the max data point of the waveform to keep for Undershoot
double timeForUndershootDetectionAfterMaxTime = this.FullWidthHalfMaxValue * undershootMaxTimeFWHMMultiplier;
// Add the undershoot allowed time to the max data point time
double endTimeForUndershootDetection = this.PeakCurrentDataPoint.X + timeForUndershootDetectionAfterMaxTime;
// Trim the waveform, removing everything before the max peak
Waveform absoluteWaveformAfterPeakCurrentTime = this.AbsoluteWaveform.TrimStart(this.PeakCurrentDataPoint.X);
// Trim the end of the waveform from the max time until 2.5x the FWHM time
Waveform absoluteUndershootApplicableWaveform = absoluteWaveformAfterPeakCurrentTime.TrimEnd(endTimeForUndershootDetection);
// Find the (absolute) undershoot data point of the absolute Current waveform after the max time
DataPoint absoluteUndershootDataPoint = absoluteUndershootApplicableWaveform.Minimum();
// Look up what the undershoot max percent can be (it is a negative value)
this.UndershootAllowedMaximumPercent = CDMJS002WaveformCharacteristics.UndershootMaxPercent(this.SignedVoltage, this.IsLargeTarget, this.OscilloscopeIsHighBandwidth);
// Calculate what the maximum undershoot value can be (it is a negative number since we are referring to undershoot)
this.UndershootAllowedMaximumValue = this.PeakCurrentValue * this.UndershootAllowedMaximumPercent;
// Convert the absolute undershoot value to the signed value
double absoluteUndershootValue = absoluteUndershootDataPoint.Y;
// If the absolute undershoot is greater than zero, set it to zero. Otherwise set it to the signed value
if (absoluteUndershootValue > 0)
{
this.UndershootValue = 0;
}
else
{
this.UndershootValue = absoluteUndershootValue.InvertValueIfNegativePolarity(this.WaveformIsPositivePolarity);
}
// Determine if the Undershoot is passing
if (this.WaveformIsPositivePolarity)
{
this.UndershootIsPassing = this.UndershootValue >= this.UndershootAllowedMaximumValue;
}
else
{
this.UndershootIsPassing = this.UndershootValue <= this.UndershootAllowedMaximumValue;
}
// Create the undershoot signed Data Point
this.UndershootDataPoint = absoluteUndershootDataPoint.InvertYValueIfNegativePolarity(this.WaveformIsPositivePolarity);
}
/// <summary>
/// Initialization of the waveform test harness components.
/// </summary>
private async void InitializeWaveform()
{
this.sampleRate = 44100;
var file = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(@"Assets\test.wav");
this.waveform = new Waveform.Builder()
.FromFile(file.Path, this.sampleRate)
.WithScale(1f)
.Build();
}
public void Run()
{
#region Create Sessions
FocusITunerBroker iTuner = new FocusITunerBroker();
iTuner.Initialize(tunerAddress, false, true);
NIRfsg nIRfsg = new NIRfsg(resourceName, false, false);
RFmxInstrMX instr = new RFmxInstrMX(resourceName, "");
RFmxSpecAnMX specAn = instr.GetSpecAnSignalConfiguration(signalStringSpecan);
#endregion
#region Configure Tuner
FocusTuner.ConfigureCommon(iTuner, commonConfiguration);
#endregion
#region Configure Generation
ConfigureInstrument(nIRfsg, sgInstrConfig);
Waveform waveform = LoadWaveformFromTDMS(filePath);
DownloadWaveform(nIRfsg, waveform);
ConfigureContinuousGeneration(nIRfsg, waveform);
nIRfsg.Initiate();
#endregion
#region Configure Analyzer
saAutolevelConfig.MeasurementInterval_s = waveform.BurstLength_s;
RFmxInstr.ConfigureInstrument(instr, saInstrConfig);
RFmxSpecAn.ConfigureCommon(specAn, saCommonConfig);
RFmxSpecAn.ConfigureTxp(specAn, txpConfigurationSpecAn);
#endregion
#region Measure
foreach (var gamma in gammaSweep)
{
Console.WriteLine("\n--------------------- Tuning --------------------\n");
currentGamma = FocusTuner.MoveTunerPerGamma(iTuner, gamma)[0];
PrintTuneResults();
Console.WriteLine("\n--------------------- Results --------------------\n");
RFmxSpecAnMXMeasurementTypes[] specanMeasurements = new RFmxSpecAnMXMeasurementTypes[1] {
RFmxSpecAnMXMeasurementTypes.Txp
};
RFmxSpecAn.SelectAndInitiateMeasurements(specAn, specanMeasurements, saAutolevelConfig, waveform.SignalBandwidth_Hz, false, "", resultStringSpecan);
txpResultsSpecAn = RFmxSpecAn.FetchTxp(specAn, RFmxSpecAnMX.BuildResultString(resultStringSpecan));
PrintTxPResults();
}
#endregion
AbortGeneration(nIRfsg);
CloseInstrument(nIRfsg);
FocusTuner.CloseTuner(iTuner);
specAn.Dispose();
specAn = null;
instr.Close();
instr = null;
}
public override Task <Empty> ConfigureContinuousGeneration(RfsgServiceGenerationConfiguration request, ServerCallContext context)
{
var rfsg = sessionMap[(IntPtr)request.Session.Handle];
Waveform wfm = new Waveform()
{
Name = request.WaveformName,
};
SG.ConfigureContinuousGeneration(rfsg, wfm, request.MarkerEventExportTerminal);
return(Task.FromResult(new Empty()));
}
public IHttpActionResult PostWaveform(Waveform waveform)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Waveforms.Add(waveform);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = waveform.WaveformID }, waveform));
}
public PreviewWaveform(Audio audio)
{
InitializeComponent();
m_info = new TimeInfo();
m_info.TotalTime = new TimeSpan(0, 0, 0, 1);
m_waveform = new Waveform(m_info);
m_waveform.BorderStyle = BorderStyle.FixedSingle;
m_waveform.Audio = audio;
m_waveform.BackColor = Color.LightGray;
m_waveform.Paint += PreviewWaveform_Paint;
Controls.Add(m_waveform);
}
/// <summary>
/// Bildet den Durschnitt aus einer Liste aus Waveforms. Die Waveforms müssen gleich lang sein.
/// </summary>
/// <param name="waveforms">Die Liste aus Waveforms.</param>
/// <returns>Die Durchschnitts-Waveform.</returns>
public static Waveform AverageWaveform(List<Waveform> waveforms)
{
int noOfWaveforms = waveforms.Count;
if (noOfWaveforms < 1) return null;
else if (noOfWaveforms < 2) return waveforms[0];
double average;
Waveform averageWaveform = new Waveform(0, waveforms[0].Rate);
for (int i = waveforms[0].First; i <= waveforms[0].Last; i++)
{
average = 0;
foreach (Waveform waveform in waveforms)
{
average = average + waveform[i];
}
average = average / noOfWaveforms;
averageWaveform.Add(average);
}
return averageWaveform;
}
protected void Load(Waveform wav,float scale=1.0f)
{
dataPoints = new List<VitalDataPoint>();
VitalDataPoint newData = new VitalDataPoint();
length = wav.samples;
dataMax = 0;
dataMin=9999;
// For each character in the file
for (int i = 0; i < length; i++)
{
newData = new VitalDataPoint();
newData.time = i;
newData.point = wav.data[i]*scale;
if (newData.point>dataMax) dataMax=newData.point;
if (newData.point<dataMin) dataMin=newData.point;
dataPoints.Add(newData);
}
dataPoints.TrimExcess();
lastPoint = dataPoints[0];
nextPoint = dataPoints[0];
}
/// <summary>
/// Findet zu einer Frequenz den nächstkleineren Index im diskreten Spektrum.
/// </summary>
/// <param name="freq">Frequenz</param>
/// <param name="realSpectrum">reellwertiges Halbspektrum</param>
/// <param name="sampleRate">Samplerate</param>
/// <returns>Index im diskreten Spektrum</returns>
private static int FindSpectrumIndexForFreq(double freq, Waveform realSpectrum, int sampleRate)
{
return (int) Math.Floor((freq / (sampleRate / 2)) * realSpectrum.Count) + realSpectrum.First;
}
/// <summary>
/// Switch the waveform at any time.
/// </summary>
/// <param name="waveform"></param>
public void ChangeWaveform(Waveform waveform)
{
if(waveform == _waveform) return;
_waveform = waveform;
}
/// <summary>
/// Generiert eine Waveform, die die sekündliche Aktivität eines EEG-Frequenzbandes wiederspiegelt und speichert sie zwischen. Die Samplerate ist 1 Hz.
/// </summary>
private void CalculateActivity()
{
this.Activity = new Dictionary<EEGBand, Waveform>();
foreach (EEGBand eegBand in (EEGBand[])Enum.GetValues(typeof(EEGBand)))
{
double minFreq = eegBand.GetMinFreq();
double maxFreq = eegBand.GetMaxFreq();
// wir nehmen das Spektrum über 128 Samples
int fftSize = 128;
// die Samplerate der Activity-Waveform soll 1 Hz sein.
int activitySampleRate = 1;
// wir benötigen eine leere Waveform
Waveform activityWaveform = new Waveform(0, activitySampleRate);
// Ermittle das Frequenzspektrum in regelmäßigen Abständen und berechne die Aktivität im Frequenzband
for (int i = Waveform.First; i <= Waveform.Last - fftSize; i = i + ((int)sampleRate / activitySampleRate))
{
Waveform amplitudeSpectrum = GetAmplitudeSpectrum(i, fftSize);
// finde die Indizes im diskreten Spektrum, die Ober- und Unterkante des Frequenzbands darstellen
int minFreqIndex = FindSpectrumIndexForFreq(minFreq, amplitudeSpectrum, (int)sampleRate);
int maxFreqIndex = FindSpectrumIndexForFreq(maxFreq, amplitudeSpectrum, (int)sampleRate);
double activityValue = 0;
for (int j = minFreqIndex; j <= maxFreqIndex; j++)
{
activityValue = activityValue + amplitudeSpectrum[j];
}
activityWaveform.Add(activityValue / (maxFreqIndex - minFreqIndex + 1));
}
// Die Waveform ist etwas zu kurz (fftSize) und die Werte beziehen sich jeweils auf zwei Sekunden später
// Kompensieren, indem die Welle nach hinten verschoben wird und die ersten Werte denselben Wert annehmen
Waveform compensationWaveform = new Waveform(0, activitySampleRate);
for (int i = 0; i <= fftSize; i = i + ((int)sampleRate / activitySampleRate))
{
compensationWaveform.Add(activityWaveform[activityWaveform.First]);
}
this.Activity.Add(eegBand, EEGUtils.Concatenate(compensationWaveform, activityWaveform));
}
}
public EEGAnalyzer(Waveform Waveform)
{
this.Waveform = Waveform;
this.sampleRate = Waveform.Rate;
CalculateActivity();
}
private void FireTriggeredWaveform(Waveform f)
{
if (TriggeredWaveform != null)
TriggeredWaveform(f);
}
void ProcessWaveform(DataPacket data)
{
AcquisitionLength = 1+(int)(AcquisitionTime*Source.SampleRate);
if (AcquisitionLength < 15) AcquisitionLength = 15;
Pretrigger = (int) (PretriggerTime*Source.SampleRate) + AcquisitionLength / 2;
lock (samplesOverflowSink)
{
samplesOverflowSink.AddRange(data.Samples);
var pretriggerSampleDepth = (int) Source.SampleRate;
if (samplesOverflowSink.Count > pretriggerSampleDepth)
{
samplesOverflowSink.RemoveRange(0, samplesOverflowSink.Count - pretriggerSampleDepth);
}
var triggerInfo = new TriggerInfo(true, 0); // dummy
while (triggerInfo.Triggered && samplesOverflowSink.Count >= AcquisitionLength + Pretrigger) // always keep 1 waveform extra in memory
{
triggerInfo = Trigger.IsTriggered(samplesOverflowSink, 0);
// Skip the waveform (if we keep trigger) till we satisfy the pretrigger requirement.
while (triggerInfo.Triggered && triggerInfo.TriggerPoint < Pretrigger)
{
triggerInfo = Trigger.IsTriggered(samplesOverflowSink, triggerInfo.TriggerPoint );
}
// Only process when actually triggered.
if (!triggerInfo.Triggered) break;
// We take the waveform from the buffer at the triggerpoint, but also subtracting the pre-trigger sample depth.
var waveformStart = triggerInfo.TriggerPoint - Pretrigger;
// Get these samples, and put them into the waveform.
var waveformSamples = samplesOverflowSink.Skip(waveformStart).Take(AcquisitionLength).ToArray();
if (waveformSamples.Length != AcquisitionLength) break;
var waveform = new Waveform(1, AcquisitionLength);
var timestamp = -Pretrigger*data.TimeInterval;
foreach(var s in waveformSamples)
{
timestamp += data.TimeInterval;
waveform.Store(timestamp, new float[1] {s});
}
FireTriggeredWaveform(waveform);
samplesOverflowSink.RemoveRange(0, waveformStart+AcquisitionLength-1);
}
}
}
void Source_Data(DataPacket data)
{
// Store each sample.
foreach (var s in data.Samples)
{
overviewTimestamp += data.TimeInterval;
overviewWf.Store(overviewTimestamp, new float[1] { s });
}
if (DateTime.Now.Subtract(overviewWfLastCapture).TotalMilliseconds >= LongAcquisitionTime *1000)
{
if (OverviewWaveform != null)
OverviewWaveform(overviewWf);
overviewWf = new Waveform(1, 6000000);
overviewTimestamp = 0.0f;
overviewWfLastCapture = DateTime.Now;
}
}
private void _DisposePreviewWaveform()
{
if (m_waveform != null)
{
m_waveform.Paint += PreviewWaveform_Paint;
m_waveform.Dispose();
m_waveform = null;
}
}
/// <summary>
/// Normalisiert mehrere Waveforms in den Bereich zwischen 0 und 1. Die Referenzen (Minimum und Maximum) werden dabei über alle Waveforms hinweg gesucht.
/// </summary>
/// <param name="waveforms">Die zu normalisierenden Waveforms. Die Liste wird durch die normalisierten Waveforms ersetzt.</param>
public static void NormalizeMultiple(ref List<Waveform> waveforms)
{
if (waveforms.Count < 1) return;
double min = waveforms[0][waveforms[0].First];
double max = waveforms[0][waveforms[0].First];
// kleinsten und größten Wert suchen
foreach (Waveform wf in waveforms)
{
for (int i = wf.First; i <= wf.Last; i++)
{
if (wf[i] < min) min = wf[i];
if (wf[i] > max) max = wf[i];
}
}
// alle Waveforms normalisieren
if (max - min > 0)
{
for (int j = 0; j < waveforms.Count; j++)
{
Waveform wf = waveforms[j];
Waveform normalizedWaveform = new Waveform(0, wf.Rate);
for (int i = wf.First; i <= wf.Last; i++)
{
// Wert normalisieren
normalizedWaveform.Add((wf[i] - min) / (max - min));
}
waveforms[j] = normalizedWaveform;
}
}
}
public Waveform CycleWaveforms()
{
WaveformType = (Waveform)((int)(WaveformType + 1) % MAX_WAVEFORM_TYPES);
return WaveformType;
}
/// <summary>
/// Add Waveform to the chart.
/// </summary>
///
/// <param name="name">Waveform name.</param>
/// <param name="color">Waveform color.</param>
/// <param name="width">Waveform width.</param>
/// <param name="updateYRange">Specifies if <see cref="RangeY"/> should be updated.</param>
///
/// <remarks><para>Adds new empty waveform to the collection of waves. To update this
/// wave the <see cref="UpdateWaveform(string, float[])"/> method should be used.</para>
/// </remarks>
///
/// <remarks><para>Adds new empty data series to the collection of data series.</para>
///
/// <para>The <b>updateYRange</b> parameter specifies if the waveform may affect displayable
/// Y range. If the value is set to false, then displayable Y range is not updated, but used the
/// range, which was specified by user (see <see cref="RangeY"/> property). In the case if the
/// value is set to true, the displayable Y range is recalculated to fully fit the new data
/// series.</para>
/// </remarks>
///
public void AddWaveform(string name, Color color, int width, bool updateYRange)
{
Waveform series = new Waveform();
series.color = color;
series.width = width;
series.updateYRange = updateYRange;
waveTable.Add(name, series);
}
public static float Evaluate( Waveform wave, float normalizedInput )
{
normalizedInput = WrapFloatToRange(normalizedInput, 0f, 1f);
if( wave == Wave.Waveform.Sin )
{
float currentAmplitude = Mathf.Sin( normalizedInput * 360 * Mathf.Deg2Rad );
return ( currentAmplitude + 1 ) * .5f; // Normalizes the current amplitude to 0 - 1
}
else if( wave == Wave.Waveform.Cos )
{
float currentAmplitude = Mathf.Cos( normalizedInput * 360 * Mathf.Deg2Rad );
return ( currentAmplitude + 1 ) * .5f; // Normalizes the current amplitude to 0 - 1
}
else if( wave == Wave.Waveform.Tan )
{
float currentAmplitude = Mathf.Tan( normalizedInput * 360 * Mathf.Deg2Rad );
return ( currentAmplitude + 1 ) * .5f; // Normalizes the current amplitude to 0 - 1
}
else if( wave == Wave.Waveform.Sqrt )
{
return Mathf.Sqrt( normalizedInput );
}
else if( wave == Wave.Waveform.Sqr )
{
return normalizedInput * normalizedInput;
}
else if( wave == Wave.Waveform.SawUp )
{
return normalizedInput;
}
else if( wave == Wave.Waveform.SawDown )
{
return 1 - normalizedInput;
}
else if( wave == Wave.Waveform.Square )
{
if( normalizedInput > .5f )
return 1;
else
return 0;
}
return 0;
}
