vs_projects/PicoSopeReader
1
0
Fork 0
Code Issues Pull Requests Releases 2 Wiki Activity
81d2444500
PicoSopeReader/dotnet example/ConsoleExample.cs

1067 lines
41 KiB
C#
Raw Normal View History

picoscopereader hinzugefügt
2017-03-09 21:49:20 +01:00
/**************************************************************************
*
* Filename: ConsoleExample.cs
*
* Copyright: Pico Technology Limited 2007
*
* Author: MJL
*
* Description:
* This is a console-mode program that demonstrates how to use the
* PS5000 driver using .NET
*
* Examples:
* Collect a block of samples immediately
* Collect a block of samples when a trigger event occurs
* Collect a block using ETS
* Collect a stream of data immediately
* Collect a stream of data when a trigger event occurs
* Set Signal Generator, using built in or custom signals
*
* History:
* 14Dec06 MJL Created
*
* Revision Info: "file %n date %f revision %v"
* ""
*
***************************************************************************/
using System;
using System.IO;
using System.Threading;
namespace ps5000example
{
struct ChannelSettings
{
public bool DCcoupled;
public Imports.Range range;
public bool enabled;
}
class Pwq
{
public Imports.PwqConditions[] conditions;
public short nConditions;
public Imports.ThresholdDirection direction;
public uint lower;
public uint upper;
public Imports.PulseWidthType type;
public Pwq(Imports.PwqConditions[] conditions,
short nConditions,
Imports.ThresholdDirection direction,
uint lower, uint upper,
Imports.PulseWidthType type)
{
this.conditions = conditions;
this.nConditions = nConditions;
this.direction = direction;
this.lower = lower;
this.upper = upper;
this.type = type;
}
}
class ConsoleExample
{
private readonly short _handle;
public const int BUFFER_SIZE = 1024;
public const int MAX_CHANNELS = 4;
public const int QUAD_SCOPE = 4;
public const int DUAL_SCOPE = 2;
uint _timebase = 8;
short _oversample = 1;
bool _scaleVoltages = true;
ushort[] inputRanges = { 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 50000 };
bool _ready = false;
int _sampleCount;
uint _startIndex;
bool _autoStop;
private ChannelSettings [] _channelSettings;
private int _channelCount;
private Imports.Range _firstRange;
private Imports.Range _lastRange;
private Imports.ps5000BlockReady _callbackDelegate;
/****************************************************************************
* Callback
* used by PS5000 data streaimng collection calls, on receipt of data.
* used to set global flags etc checked by user routines
****************************************************************************/
void StreamingCallback(short handle,
int noOfSamples,
uint startIndex,
short ov,
uint triggerAt,
short triggered,
short autoStop,
IntPtr pVoid)
{
// used for streaming
_sampleCount = noOfSamples;
_startIndex = startIndex;
_autoStop = autoStop != 0;
// flag to say done reading data
_ready = true;
}
/****************************************************************************
* Callback
* used by PS5000 data block collection calls, on receipt of data.
* used to set global flags etc checked by user routines
****************************************************************************/
void BlockCallback(short handle, short status, IntPtr pVoid)
{
// flag to say done reading data
_ready = true;
}
/****************************************************************************
* SetDefaults - restore default settings
****************************************************************************/
void SetDefaults()
{
int sampleTime;
Imports.SetEts(_handle, Imports.EtsMode.Off, 0, 0, out sampleTime); // Turn off ETS
for (int i = 0; i < _channelCount; i++) // reset channels to most recent settings
{
Imports.SetChannel(_handle, Imports.Channel.ChannelA + i,
(short)(_channelSettings[(int)(Imports.Channel.ChannelA + i)].enabled ? 1 : 0),
(short) (_channelSettings[(int)(Imports.Channel.ChannelA + i)].DCcoupled ? 1 : 0),
_channelSettings[(int)(Imports.Channel.ChannelA + i)].range);
}
}
/****************************************************************************
* adc_to_mv
*
* If the user selects scaling to millivolts,
* Convert an 16-bit ADC count into millivolts
****************************************************************************/
int adc_to_mv(int raw, int ch)
{
return (_scaleVoltages) ? (raw * inputRanges[ch]) / Imports.MaxValue : raw;
}
/****************************************************************************
* mv_to_adc
*
* Convert a millivolt value into a 16-bit ADC count
*
* (useful for setting trigger thresholds)
****************************************************************************/
short mv_to_adc(short mv, short ch)
{
return (short)((mv * Imports.MaxValue) / inputRanges[ch]);
}
/****************************************************************************
* BlockDataHandler
* - Used by all block data routines
* - acquires data (user sets trigger mode before calling), displays 10 items
* and saves all to data.txt
* Input :
* - unit : the unit to use.
* - text : the text to display before the display of data slice
* - offset : the offset into the data buffer to start the display's slice.
****************************************************************************/
void BlockDataHandler(string text, int offset)
{
uint sampleCount = BUFFER_SIZE;
PinnedArray<short>[] minPinned = new PinnedArray<short>[_channelCount];
PinnedArray<short>[] maxPinned = new PinnedArray<short>[_channelCount];
int timeIndisposed;
for (int i = 0; i < _channelCount; i++)
{
short [] minBuffers = new short[sampleCount];
short [] maxBuffers = new short[sampleCount];
minPinned[i] = new PinnedArray<short>(minBuffers);
maxPinned[i] = new PinnedArray<short>(maxBuffers);
Imports.SetDataBuffers(_handle, (Imports.Channel)i, minBuffers, maxBuffers, (int)sampleCount);
}
/* find the maximum number of samples, the time interval (in timeUnits),
* the most suitable time units, and the maximum _oversample at the current _timebase*/
int timeInterval;
int maxSamples;
while (Imports.GetTimebase(_handle, _timebase, (int)sampleCount, out timeInterval, _oversample, out maxSamples, 0) != 0)
{
_timebase++;
}
Console.WriteLine("Timebase: {0}\toversample:{1}", _timebase, _oversample);
/* Start it collecting, then wait for completion*/
_ready = false;
_callbackDelegate = BlockCallback;
Imports.RunBlock(_handle, 0, (int)sampleCount, _timebase, _oversample, out timeIndisposed, 0, _callbackDelegate,
IntPtr.Zero);
/*Console.WriteLine("Run Block : {0}", status);*/
Console.WriteLine("Waiting for data...Press a key to abort");
while (!_ready && !Console.KeyAvailable)
{
Thread.Sleep(100);
}
if(Console.KeyAvailable) Console.ReadKey(true); // clear the key
Imports.Stop(_handle);
if (_ready)
{
short overflow;
Imports.GetValues(_handle, 0, ref sampleCount, 1, Imports.DownSamplingMode.None, 0, out overflow);
/* Print out the first 10 readings, converting the readings to mV if required */
Console.WriteLine(text);
Console.WriteLine("Value {0}", (_scaleVoltages) ? ("mV") : ("ADC Counts"));
for (int i = offset; i < offset + 10; i++)
{
for (int j = 0; j < _channelCount; j++)
{
if (_channelSettings[j].enabled)
{
Console.Write("{0}\t", adc_to_mv(minPinned[j].Target[i], (int)_channelSettings[(int)(Imports.Channel.ChannelA + j)].range));
}
}
Console.WriteLine();
}
sampleCount = Math.Min(sampleCount, BUFFER_SIZE);
TextWriter writer = new StreamWriter("data.txt", false);
for (int i = 0; i < sampleCount; i++)
{
for (int j = 0; j < _channelCount; j++)
{
writer.Write("{0}", (i * timeInterval));
if (_channelSettings[j].enabled)
{
writer.WriteLine(", {0}, {1}, {2}, {3}",
minPinned[j].Target[i],
adc_to_mv(minPinned[j].Target[i],
(int)_channelSettings[(int)(Imports.Channel.ChannelA + j)].range),
maxPinned[j].Target[i],
adc_to_mv(maxPinned[j].Target[i],
(int)_channelSettings[(int)(Imports.Channel.ChannelA + j)].range));
}
}
writer.WriteLine();
}
writer.Close();
}
else
{
Console.WriteLine("data collection aborted");
WaitForKey();
}
}
private void RapidBlockDataHandler(ushort nRapidCaptures)
{
short status;
int numChannels = _channelCount;
uint numSamples = BUFFER_SIZE;
// Run the rapid block capture
int timeIndisposed;
_ready = false;
_callbackDelegate = BlockCallback;
Imports.RunBlock(_handle,
0,
(int)numSamples,
_timebase,
_oversample,
out timeIndisposed,
0,
_callbackDelegate,
IntPtr.Zero);
// Set up the data arrays and pin them
short[][][] values = new short[nRapidCaptures][][];
PinnedArray<short>[,] pinned = new PinnedArray<short>[nRapidCaptures, numChannels];
for (ushort segment = 0; segment < nRapidCaptures; segment++)
{
values[segment] = new short[numChannels][];
for (short channel = 0; channel < numChannels; channel++)
{
if (_channelSettings[channel].enabled)
{
values[segment][channel] = new short[numSamples];
pinned[segment, channel] = new PinnedArray<short>(values[segment][channel]);
status = Imports.SetDataBuffersRapid(_handle,
(Imports.Channel)channel,
values[segment][channel],
(int)numSamples,
segment);
}
else
{
status = Imports.SetDataBuffersRapid(_handle,
(Imports.Channel)channel,
null,
0,
segment);
}
}
}
// Read the data
short [] overflows = new short[nRapidCaptures];
status = Imports.GetValuesRapid(_handle, ref numSamples, 0, (ushort)(nRapidCaptures - 1), overflows);
// Un-pin the arrays
foreach (PinnedArray<short> p in pinned)
{
if (p != null)
p.Dispose();
}
//TODO: Do what ever is required with the data here.
}
short SetTrigger(Imports.TriggerChannelProperties[] channelProperties, short nChannelProperties, Imports.TriggerConditions[] triggerConditions, short nTriggerConditions, Imports.ThresholdDirection[] directions, Pwq pwq, uint delay, short auxOutputEnabled, int autoTriggerMs)
{
short status;
if (
(status =
Imports.SetTriggerChannelProperties(_handle, channelProperties, nChannelProperties, auxOutputEnabled,
autoTriggerMs)) != 0)
{
return status;
}
if ((status = Imports.SetTriggerChannelConditions(_handle, triggerConditions, nTriggerConditions)) != 0)
{
return status;
}
if (directions == null) directions = new Imports.ThresholdDirection[] { Imports.ThresholdDirection.None,
Imports.ThresholdDirection.None, Imports.ThresholdDirection.None, Imports.ThresholdDirection.None,
Imports.ThresholdDirection.None, Imports.ThresholdDirection.None};
if ((status = Imports.SetTriggerChannelDirections(_handle,
directions[(int)Imports.Channel.ChannelA],
directions[(int)Imports.Channel.ChannelB],
directions[(int)Imports.Channel.ChannelC],
directions[(int)Imports.Channel.ChannelD],
directions[(int)Imports.Channel.External],
directions[(int)Imports.Channel.Aux])) != 0)
{
return status;
}
if ((status = Imports.SetTriggerDelay(_handle, delay)) != 0)
{
return status;
}
if (pwq == null) pwq = new Pwq(null, 0, Imports.ThresholdDirection.None, 0, 0, Imports.PulseWidthType.None);
status = Imports.SetPulseWidthQualifier(_handle, pwq.conditions,
pwq.nConditions, pwq.direction,
pwq.lower, pwq.upper, pwq.type);
return status;
}
/****************************************************************************
* CollectBlockImmediate
* this function demonstrates how to collect a single block of data
* from the unit (start collecting immediately)
****************************************************************************/
void CollectBlockImmediate()
{
Console.WriteLine("Collect block immediate...");
Console.WriteLine("Press a key to start");
WaitForKey();
SetDefaults();
/* Trigger disabled */
SetTrigger(null, 0, null, 0, null, null, 0, 0, 0);
BlockDataHandler("First 10 readings", 0);
}
void CollectBlockRapid()
{
ushort numRapidCaptures;
Console.WriteLine("Collect rapid block...");
Console.WriteLine("Specify number of captures:");
do
{
numRapidCaptures = ushort.Parse(Console.ReadLine());
} while (Imports.SetNoOfRapidCaptures(_handle, numRapidCaptures) > 0);
int maxSamples;
Imports.MemorySegments(_handle, numRapidCaptures, out maxSamples);
Console.WriteLine("Collecting {0} rapid blocks. Press a key to start", numRapidCaptures);
WaitForKey();
SetDefaults();
/* Trigger is optional, disable it for now */
SetTrigger(null, 0, null, 0, null, null, 0, 0, 0);
RapidBlockDataHandler(numRapidCaptures);
}
private static void WaitForKey()
{
while(!Console.KeyAvailable) Thread.Sleep(100);
if (Console.KeyAvailable) Console.ReadKey(true); // clear the key
}
/****************************************************************************
* CollectBlockEts
* this function demonstrates how to collect a block of
* data using equivalent time sampling (ETS).
****************************************************************************/
void CollectBlockEts()
{
int ets_sampletime;
short triggerVoltage = mv_to_adc(100, (short)_channelSettings[(int)Imports.Channel.ChannelA].range); // ChannelInfo stores ADC counts
Imports.TriggerChannelProperties[] sourceDetails = new Imports.TriggerChannelProperties[] {
new Imports.TriggerChannelProperties( triggerVoltage, triggerVoltage, 10, Imports.Channel.ChannelA, Imports.ThresholdMode.Level )};
Imports.TriggerConditions[] conditions = new Imports.TriggerConditions[] {
new Imports.TriggerConditions(Imports.TriggerState.True,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare)};
Imports.ThresholdDirection[] directions = new Imports.ThresholdDirection[]
{ Imports.ThresholdDirection.Rising,
Imports.ThresholdDirection.None,
Imports.ThresholdDirection.None,
Imports.ThresholdDirection.None,
Imports.ThresholdDirection.None,
Imports.ThresholdDirection.None };
Console.WriteLine("Collect ETS block...");
Console.WriteLine("Collects when value rises past {0}mV", adc_to_mv(sourceDetails[0].ThresholdMajor,
(int)_channelSettings[(int)Imports.Channel.ChannelA].range));
Console.WriteLine("Press a key to start...");
WaitForKey();
SetDefaults();
/* Trigger enabled
* Rising edge
* Threshold = 1500mV
* 10% pre-trigger (negative is pre-, positive is post-) */
short status = SetTrigger(sourceDetails, 1, conditions, 1, directions, null, 0, 0, 0);
Console.WriteLine("Set Trigger : {0}", status);
/* Enable ETS in fast mode, the computer will store 100 cycles but interleave only 10 */
status = Imports.SetEts(_handle, Imports.EtsMode.Fast, 20, 4, out ets_sampletime);
Console.WriteLine("Set ETS : {0}", status);
Console.WriteLine("ETS Sample Time is: {0}", ets_sampletime);
BlockDataHandler("Ten readings after trigger", BUFFER_SIZE / 10 - 5); // 10% of data is pre-trigger
}
/****************************************************************************
* CollectBlockTriggered
* this function demonstrates how to collect a single block of data from the
* unit, when a trigger event occurs.
****************************************************************************/
void CollectBlockTriggered()
{
short triggerVoltage = mv_to_adc(1000, (short)_channelSettings[(int)Imports.Channel.ChannelA].range); // ChannelInfo stores ADC counts
Imports.TriggerChannelProperties[] sourceDetails = new Imports.TriggerChannelProperties[] {
new Imports.TriggerChannelProperties(triggerVoltage,
triggerVoltage,
256*10,
Imports.Channel.ChannelA,
Imports.ThresholdMode.Level)};
Imports.TriggerConditions[] conditions = new Imports.TriggerConditions[] {
new Imports.TriggerConditions(Imports.TriggerState.True,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare)};
Imports.ThresholdDirection[] directions = new Imports.ThresholdDirection[]
{ Imports.ThresholdDirection.Falling,
Imports.ThresholdDirection.None,
Imports.ThresholdDirection.None,
Imports.ThresholdDirection.None,
Imports.ThresholdDirection.None,
Imports.ThresholdDirection.None };
Console.WriteLine("Collect block triggered...");
Console.WriteLine("Collects when value rises past {0}mV",
adc_to_mv(sourceDetails[0].ThresholdMajor,
(int)_channelSettings[(int)Imports.Channel.ChannelA].range));
Console.WriteLine("Press a key to start...");
WaitForKey();
SetDefaults();
/* Trigger enabled
* Rising edge
* Threshold = 100mV */
SetTrigger(sourceDetails, 1, conditions, 1, directions, null, 0, 0, 0);
BlockDataHandler("Ten readings after trigger", 0);
}
/****************************************************************************
* Initialise unit' structure with Variant specific defaults
****************************************************************************/
void GetDeviceInfo()
{
string[] description = {
"Driver Version",
"USB Version",
"Hardware Version",
"Variant Info",
"Serial",
"Error Code"
};
System.Text.StringBuilder line = new System.Text.StringBuilder(80);
if (_handle >= 0)
{
for (int i = 0; i < 5; i++)
{
short requiredSize;
Imports.GetUnitInfo(_handle, line, 80, out requiredSize, i);
Console.WriteLine("{0}: {1}", description[i], line);
}
}
}
/****************************************************************************
* Select input voltage ranges for channels A and B
****************************************************************************/
void SetVoltages()
{
/* See what ranges are available... */
for (int i = (int)_firstRange; i <= (int)_lastRange; i++)
{
Console.WriteLine("{0} . {1} mV", i, inputRanges[i]);
}
/* Ask the user to select a range */
Console.WriteLine("Specify voltage range ({0}..{1})", _firstRange, _lastRange);
Console.WriteLine("99 - switches channel off");
for (int ch = 0; ch < _channelCount; ch++)
{
Console.WriteLine("");
uint range;
do
{
Console.WriteLine("Channel: {0}", (char)('A' + ch));
range = uint.Parse(Console.ReadLine());
} while (range != 99 && (range < (uint)_firstRange || range > (uint)_lastRange));
if (range != 99)
{
_channelSettings[ch].range = (Imports.Range)range;
Console.WriteLine(" - {0} mV", inputRanges[range]);
_channelSettings[ch].enabled = true;
}
else
{
Console.WriteLine("Channel Switched off");
_channelSettings[ch].enabled = false;
}
}
}
/****************************************************************************
*
* Select _timebase, set _oversample to on and time units as nano seconds
*
****************************************************************************/
void SetTimebase()
{
int timeInterval;
int maxSamples;
Console.WriteLine("Specify timebase (not 0): ");
do
{
_timebase = uint.Parse(Console.ReadLine());
} while (_timebase == 0);
Imports.GetTimebase(_handle, _timebase, BUFFER_SIZE, out timeInterval, 1, out maxSamples, 0);
Console.WriteLine("Timebase {0} - {1} ns", _timebase, timeInterval);
_oversample = 1;
}
/****************************************************************************
* Toggles the signal generator
* - allows user to set frequency and waveform
* - allows for custom waveform (values 0..4192) of up to 8192 samples long
***************************************************************************/
void SetSignalGenerator()
{
short status;
short waveform;
long frequency;
short[] arbitraryWaveform = new short[8192];
short waveformSize = 0;
Console.WriteLine("Enter frequency in Hz: "); // Ask user to enter signal frequency;
do
{
frequency = long.Parse(Console.ReadLine());
} while (frequency < 1000 || frequency > 10000000);
if (frequency > 0) // Ask user to enter type of signal
{
Console.WriteLine("Signal generator On");
Console.WriteLine("Enter type of waveform (0..9 or 99)");
Console.WriteLine("0:\tSINE");
Console.WriteLine("1:\tSQUARE");
Console.WriteLine("2:\tTRIANGLE");
Console.WriteLine("99:\tUSER WAVEFORM");
Console.WriteLine(" \t(see manual for more)");
do
{
waveform = short.Parse(Console.ReadLine());
} while (waveform != 99 && (waveform < 0 || waveform >= (short)Imports.SiggenWaveType.MAX_WAVE_TYPES));
if (waveform == 99) // custom waveform selected - user needs to select file
{
waveformSize = 0;
Console.WriteLine("Select a waveform file to load: ");
string fileName;
fileName = Console.ReadLine();
if (File.Exists(fileName))
{
TextReader reader = new StreamReader(fileName);
// Having opened file, read in data - one number per line (at most 8192 lines), with values in (0..4191)
string text = reader.ReadLine();
while (text != null && waveformSize < arbitraryWaveform.Length)
{
arbitraryWaveform[waveformSize++] = short.Parse(text);
text = reader.ReadLine();
}
}
else
{
Console.WriteLine("Invalid filename");
return;
}
}
}
else
{
waveform = 0;
Console.WriteLine("Signal generator Off");
}
if (waveformSize > 0)
{
double delta = ((frequency * waveformSize) / 8192) * 4294967296.0 * 8e-9; // delta >= 10
status = Imports.SetSiggenArbitrary(_handle, 0, 4000000, (uint)delta, (uint)delta, 0, 0, arbitraryWaveform,
(uint)waveformSize, Imports.SiggenSweepType.Up, false, Imports.SiggenIndexMode.Single, 0, 0,
Imports.SiggenTrigType.Rising, Imports.SiggenTrigSource.None, 0);
}
else
{
status = Imports.SetSiggenBuiltIn(_handle, 0, 4000000, (Imports.SiggenWaveType)waveform, frequency, frequency, 0, 0,
Imports.SiggenSweepType.Up, false, 0, 0, Imports.SiggenTrigType.Rising, Imports.SiggenTrigSource.None, 0);
}
Console.WriteLine("Set Signal Generator : {0}", status);
}
/****************************************************************************
* Stream Data Handler
* - Used by the two stream data examples - untriggered and triggered
* Inputs:
* - unit - the unit to sample on
* - preTrigger - the number of samples in the pre-trigger phase
* (0 if no trigger has been set)
***************************************************************************/
void StreamDataHandler(uint preTrigger)
{
uint sampleCount = BUFFER_SIZE*10; /* *10 is to make sure buffer large enough */
short[][] minBuffers = new short[_channelCount][];
short[][] maxBuffers = new short[_channelCount][];
uint sampleInterval = 1;
for (int i = 0; i < _channelCount; i++) // create data buffers
{
minBuffers[i] = new short[sampleCount];
maxBuffers[i] = new short[sampleCount];
Imports.SetDataBuffers(_handle, (Imports.Channel) i, minBuffers[i], maxBuffers[i], (int) sampleCount);
}
Console.WriteLine("Waiting for trigger...Press a key to abort");
_autoStop = false;
short status = Imports.RunStreaming(_handle, ref sampleInterval, Imports.ReportedTimeUnits.MicroSeconds,
preTrigger, 1000000 - preTrigger, true, 1000, sampleCount);
Console.WriteLine("Run Streaming : {0} ", status);
Console.WriteLine("Streaming data...Press a key to abort");
TextWriter writer = new StreamWriter("test.out", false);
while (!_autoStop && !Console.KeyAvailable)
{
/* Poll until data is received. Until then, GetStreamingLatestValues wont call the callback */
Thread.Sleep(100);
_ready = false;
Imports.GetStreamingLatestValues(_handle, StreamingCallback, IntPtr.Zero);
if (_ready && _sampleCount > 0) /* can be ready and have no data, if autoStop has fired */
{
Console.WriteLine("Collected {0} samples, index = {1}", _sampleCount, _startIndex);
for (uint i = _startIndex; i < (_startIndex + _sampleCount); i++)
{
for (int j = 0; j < _channelCount; j++)
{
if (_channelSettings[j].enabled)
{
writer.Write("{0}, {1}, {2}, {3},",
minBuffers[j][i],
adc_to_mv(minBuffers[j][i], (int) _channelSettings[(int) (Imports.Channel.ChannelA + j)].range),
maxBuffers[j][i],
adc_to_mv(maxBuffers[j][i], (int) _channelSettings[(int) (Imports.Channel.ChannelA + j)].range));
}
}
writer.WriteLine();
}
}
}
if (Console.KeyAvailable) Console.ReadKey(true); // clear the key
Imports.Stop(_handle);
writer.Close();
if (!_autoStop)
{
Console.WriteLine("data collection aborted");
WaitForKey();
}
}
/****************************************************************************
* CollectStreamingImmediate
* this function demonstrates how to collect a stream of data
* from the unit (start collecting immediately)
***************************************************************************/
void CollectStreamingImmediate()
{
SetDefaults();
Console.WriteLine("Collect streaming...");
Console.WriteLine("Data is written to disk file (test.out)");
Console.WriteLine("Press a key to start");
WaitForKey();
/* Trigger disabled */
SetTrigger(null, 0, null, 0, null, null, 0, 0, 0);
StreamDataHandler(0);
}
/****************************************************************************
* CollectStreamingTriggered
* this function demonstrates how to collect a stream of data
* from the unit (start collecting on trigger)
***************************************************************************/
void CollectStreamingTriggered()
{
short triggerVoltage = mv_to_adc( 100, (short) _channelSettings[(int) Imports.Channel.ChannelA].range); // ChannelInfo stores ADC counts
Imports.TriggerChannelProperties[] sourceDetails = new Imports.TriggerChannelProperties[] {
new Imports.TriggerChannelProperties( triggerVoltage, triggerVoltage, 256 * 10, Imports.Channel.ChannelA, Imports.ThresholdMode.Level )};
Imports.TriggerConditions[] conditions = new Imports.TriggerConditions[] {
new Imports.TriggerConditions(Imports.TriggerState.True,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare)};
Imports.ThresholdDirection[] directions = new Imports.ThresholdDirection[]
{ Imports.ThresholdDirection.Rising,
Imports.ThresholdDirection.None,
Imports.ThresholdDirection.None,
Imports.ThresholdDirection.None,
Imports.ThresholdDirection.None,
Imports.ThresholdDirection.None };
Console.WriteLine("Collect streaming triggered...");
Console.WriteLine("Data is written to disk file (test.out)");
Console.WriteLine("Press a key to start");
WaitForKey();
SetDefaults();
/* Trigger enabled
* Rising edge
* Threshold = 100mV */
SetTrigger(sourceDetails, 1, conditions, 1, directions, null, 0, 0, 0);
StreamDataHandler(100000);
}
public void Run()
{
// setup devices
GetDeviceInfo();
_timebase = 1;
_firstRange = Imports.Range.Range_100MV;
_lastRange = Imports.Range.Range_20V;
_channelCount = DUAL_SCOPE;
_channelSettings = new ChannelSettings[MAX_CHANNELS];
for (int i = 0; i < MAX_CHANNELS; i++)
{
_channelSettings[i].enabled = true;
_channelSettings[i].DCcoupled = true;
_channelSettings[i].range = Imports.Range.Range_5V;
}
// main loop - read key and call routine
char ch = ' ';
while (ch != 'X')
{
Console.WriteLine("");
Console.WriteLine("B - immediate block V - Set voltages");
Console.WriteLine("T - triggered block I - Set timebase");
Console.WriteLine("R - rapid block F - toggle signal generator on/off");
Console.WriteLine("E - ETS block A - ADC counts/mV");
Console.WriteLine("S - immediate streaming Y - K<>lscheJung");
Console.WriteLine("W - triggered streaming");
Console.WriteLine(" X - exit");
Console.WriteLine("Operation:");
ch = char.ToUpper(Console.ReadKey().KeyChar);
Console.WriteLine("\n");
switch (ch)
{
case 'B':
CollectBlockImmediate();
break;
case 'T':
CollectBlockTriggered();
break;
case 'R':
CollectBlockRapid();
break;
case 'S':
CollectStreamingImmediate();
break;
case 'W':
CollectStreamingTriggered();
break;
case 'F':
SetSignalGenerator();
break;
case 'E':
CollectBlockEts();
break;
case 'V':
SetVoltages();
break;
case 'I':
SetTimebase();
break;
case 'A':
_scaleVoltages = !_scaleVoltages;
if (_scaleVoltages)
{
Console.WriteLine("Readings will be scaled in mV");
}
else
{
Console.WriteLine("Readings will be scaled in ADC counts");
}
break;
case 'X':
/* Handled by outer loop */
break;
case 'Y':
Console.WriteLine("Fun27");
Meins();
break;
default:
Console.WriteLine("Invalid operation");
break;
}
}
}
private void Meins()
{
Console.WriteLine("Chan A einschalten und auf 5V: {0}", Imports.SetChannel(_handle, Imports.Channel.ChannelA, 1, 1, Imports.Range.Range_5V));
Console.WriteLine("Chan B einschalten und auf 1V: {0}", Imports.SetChannel(_handle, Imports.Channel.ChannelB, 1, 1, Imports.Range.Range_1V));
int tmp;
Console.WriteLine("Disable ETS: {0}", Imports.SetEts(_handle, Imports.EtsMode.Off, 0, 0,out tmp));
int timeInterval;
int maxSamples;
uint sampleCount = (int)(1*1e6);
_timebase = 5; //timebase = 5 => 24ns => 40mhz
_oversample = 1;
//(noSamples = Maximum Samples, oversample = 1, segemnt Index = 0);
Console.WriteLine("Zeit Setzen: {0}", Imports.GetTimebase(_handle, _timebase, (int)sampleCount, out timeInterval, _oversample, out maxSamples, 0));
short triggerVoltage = mv_to_adc(3000, (short)Imports.Range.Range_5V);
Console.WriteLine("max {0} {1}:", Imports.MaxValue, triggerVoltage);
Imports.TriggerChannelProperties[] sourceDetails = new Imports.TriggerChannelProperties[] {
new Imports.TriggerChannelProperties(
triggerVoltage,
triggerVoltage,
1,
Imports.Channel.ChannelA,
Imports.ThresholdMode.Level)};
Console.WriteLine("Trigger Einstellungen auf Chan A setzen: {0}", Imports.SetTriggerChannelProperties(_handle, sourceDetails, (short)sourceDetails.Length, 0, 0));
Imports.TriggerConditions[] cond = new Imports.TriggerConditions[] {
new Imports.TriggerConditions(
Imports.TriggerState.True,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare,
Imports.TriggerState.DontCare)};
Console.WriteLine("Trigger Bedingung auf Chan A setzen: {0}", Imports.SetTriggerChannelConditions(_handle, cond, (short)cond.Length));
Imports.ThresholdDirection dir_i = Imports.ThresholdDirection.Falling;
Imports.ThresholdDirection dir_n = Imports.ThresholdDirection.None;
Console.WriteLine("Trigger Richtung auf Chan A setzen: {0}", Imports.SetTriggerChannelDirections(_handle, dir_i, dir_n, dir_n, dir_n, dir_n, dir_n));
Console.WriteLine("Trigger Verz<72>gerung setzen: {0}", Imports.SetTriggerDelay(_handle, 0));
Console.WriteLine("Alloc Buffer A (Chan A)");
short[] Buffer_A = new short[sampleCount];
Console.WriteLine("Alloc Buffer B (Chan B)");
short[] Buffer_B = new short[sampleCount];
Console.WriteLine("Buffer ChanA Setzen: {0}", Imports.SetDataBuffer(_handle, Imports.Channel.ChannelA, Buffer_A, sampleCount));
Console.WriteLine("Buffer ChanB Setzen: {0}", Imports.SetDataBuffer(_handle, Imports.Channel.ChannelB, Buffer_B, sampleCount));
_ready = false;
int timeIndisposed;
Console.WriteLine("Trigger Starten: {0}", Imports.RunBlock(_handle, 0, (int)sampleCount, _timebase, _oversample, out timeIndisposed, 0, BlockCallback, IntPtr.Zero));
Console.WriteLine("======================================================\n" +
"Gestartet, wenn Sie keine Lust mehr haben, dr<64>cken sie irgend eine Taste");
while (!_ready && !Console.KeyAvailable)
{
Thread.Sleep(100);
}
if (Console.KeyAvailable)
Console.ReadKey(true);
Imports.Stop(_handle);
if (_ready)
{
short overflow;
Console.WriteLine("Bekomme werte zur<75>ck: {0}", Imports.GetValues(_handle, 0, ref sampleCount, 1, Imports.DownSamplingMode.None, 0, out overflow));
Console.WriteLine("Buffergr<67><72>e {0}", sampleCount);
StreamWriter chan_a = new StreamWriter("Chan_A.txt");
StreamWriter chan_b = new StreamWriter("Chan_B.txt");
for (int i = 0; i < sampleCount; i++)
{
chan_a.WriteLine(adc_to_mv(Buffer_A[i], (short)Imports.Range.Range_5V));
chan_b.WriteLine(adc_to_mv(Buffer_B[i], (short)Imports.Range.Range_1V));
}
chan_a.Close();
chan_b.Close();
Console.WriteLine("Dateien geschrieben!");
}
}
private ConsoleExample(short handle)
{
_handle = handle;
}
static void Main()
{
Console.WriteLine("PS5000 driver example program");
Console.WriteLine("Version 1.0\n");
//open unit and show splash screen
Console.WriteLine("\n\nOpening the device...");
short handle;
short status = Imports.OpenUnit(out handle);
Console.WriteLine("Handle: {0}", handle);
if (status != 0)
{
Console.WriteLine("Unable to open device");
Console.WriteLine("Error code : {0}", status);
WaitForKey();
}
else
{
Console.WriteLine("Device opened successfully\n");
ConsoleExample consoleExample = new ConsoleExample(handle);
consoleExample.Run();
Imports.CloseUnit(handle);
}
}
}
}
Reference in New Issue Copy Permalink