Regarding the scaling of the axes, you can certainly edit them using the properties, and I guess you could make your own interface with text boxes and buttons or sliders or whatever, but there is a feature that is not very discoverable that you should use: If the InteractionMode of the axis is set to allow user interaction, and the scaling is set to Fixed (not "AutoScale___"), you can take the following actions while the application is running. You may have to click the graph to properly assign focus.
- Shift+Scroll-wheel: Zoom in and out around the current pointer location (cursor changes to a magnifying glass)
- Shift+Left-mouse-drag: Draws a rectangle around a region and zooms to that rectangle
- Ctrl+Left-mouse-drag: Changes the cursor to a hand and allows panning the graph
- Ctrl+Right-click or Shift+Right-click: Undo the last zoom/pan action
These can be difficult to remember, so I often add a ToolTip or label to my graph saying something like "Hold shift to zoom and control to pan. Right click to go back." so that it's a little more discoverable for my end users.
For the signal generation problem, I wasn't able to get that to work with Standard, I ended up rolling my own simple sine wave generator, the core of which looks like this:
public double[] Next()
{
for (int i = 0; i <= this.sampleCount - 1; i++)
{
// next angle = time delta / period * 2 pi = time delta * 1/f * 2pi = time delta * f * 2pi
var nextAngle = previousAngle + (2 * Math.PI * timeDelta * this.frequency);
var nextValue = Math.Sin(nextAngle) * this.amplitude;
// Change amplitude when passing through 0 to avoid discontinuities
if (nextAmplitudePending & ((previousAngle <= Math.PI & nextAngle > Math.PI) | (previousAngle <= 2 * Math.PI & nextAngle > 2 * Math.PI)))
{
nextAmplitudePending = false;
amplitude = nextAmplitude;
// No need to update nextAngle as we've only changed the amplitude
nextValue = Math.Sin(nextAngle) * this.amplitude;
}
// Change frequency when passing through max amplitude (when derivative is zero) to avoid discontinuities
// May not be strictly necessary; since we step only previous value + tiny angle, frequency change can happen smoothly at any time
//If nextFrequencyPending And
// ((previousAngle < Math.PI / 2 And nextAngle > Math.PI / 2) Or
// (previousAngle < 3 * Math.PI / 2 And nextAngle > 3 * Math.PI / 2)) Then
if (nextFrequencyPending)
{
frequency = nextFrequency;
nextFrequencyPending = false;
nextAngle = previousAngle + (2 * Math.PI * timeDelta * this.frequency);
nextValue = Math.Sin(nextAngle) * this.amplitude;
}
// Offset angle back by 2 Pi if possible
if (nextAngle > 2 * Math.PI)
{
nextAngle -= 2 * Math.PI;
}
var span = 1;
var offset = 0;
Values[i] = (nextValue - offset) / span;
previousAngle = nextAngle;
previousValue = nextValue;
}
return Values;
}
and the class for which is attached.
There is also a sine generator in the Ni Daq examples under Analog Out\Generate Voltage\ContGenVoltageWfm_IntClk\CS\FunctionGenerator.cs, but that only generates buffers that have a integer number of cycles per buffer. That's great if your application doesn't need to change the amplitude on the fly, and can use WriteRegenerationMode.AllowRegeneration, but doesn't work well for live updates.
