public void Post()
{
//FORWARD WHEELCHAIR
double Voltagevalue0, Voltagevalue1;
Voltagevalue0 = 2.77;
Voltagevalue1 = 2.5;
NationalInstruments.DAQmx.Task analogOut0 = new NationalInstruments.DAQmx.Task();
NationalInstruments.DAQmx.Task analogOut1 = new NationalInstruments.DAQmx.Task();
AOChannel ChanelAO0, ChanelAO1;
ChanelAO0 = analogOut0.AOChannels.CreateVoltageChannel("dev2/ao0", "ChanelAO0", 0, 5, AOVoltageUnits.Volts);
ChanelAO1 = analogOut1.AOChannels.CreateVoltageChannel("dev2/ao1", "ChanelAO1", 0, 5, AOVoltageUnits.Volts);
AnalogSingleChannelWriter writer0 = new AnalogSingleChannelWriter(analogOut0.Stream);
writer0.WriteSingleSample(true, Voltagevalue0);
AnalogSingleChannelWriter writer1 = new AnalogSingleChannelWriter(analogOut1.Stream);
writer1.WriteSingleSample(true, Voltagevalue1);
}
public override void AcquisitionStarting()
{
// initialise the output hardware
outputTask = new Task("analog output");
if (!Environs.Debug)
{
AnalogOutputChannel oc =
(AnalogOutputChannel) Environs.Hardware.AnalogOutputChannels[(string)settings["channel"]];
oc.AddToTask(outputTask, oc.RangeLow, oc.RangeHigh);
writer = new AnalogSingleChannelWriter(outputTask.Stream);
writer.WriteSingleSample(true, 0);
}
scanParameter = 0;
//go gently to the correct start position
if ((string)settings["scanMode"] == "up" || (string)settings["scanMode"] == "updown")
{
if ((string)settings["flyback"] == "overshoot") rampOutputToVoltage((double)settings["overshootVoltage"]);
rampOutputToVoltage((double)settings["start"]);
}
if ((string)settings["scanMode"] == "down" || (string)settings["scanMode"] == "downup")
{
if ((string)settings["flyback"] == "overshoot") rampOutputToVoltage((double)settings["overshootVoltage"]);
rampOutputToVoltage((double)settings["end"]);
}
}
internal ChannelOutput(double samplingRate, double outputRefreshTime, double inputRefreshTime, Task spikeTask, String NIDevice, int NIChannel)
{
//Compute buffer length, instantiate buffer
int multiple = (int)(Math.Round(outputRefreshTime / inputRefreshTime)); //Get number of input buffer reads that approximate the desired output rate
if (multiple < 1)
{
multiple = 1; //Ensure the multiple is at least 1
}
int bufferLength = (int)((double)multiple * inputRefreshTime * samplingRate); //Calculate length
buffer = new double[bufferLength];
//Create new task
analogOutputTask = new Task("Playback Analog Output Task");
analogOutputTask.AOChannels.CreateVoltageChannel(NIDevice + "/ao" + NIChannel, "",
-10.0, 10.0, AOVoltageUnits.Volts);
analogOutputTask.Timing.ReferenceClockSource = spikeTask.Timing.ReferenceClockSource;
analogOutputTask.Timing.ReferenceClockRate = spikeTask.Timing.ReferenceClockRate;
analogOutputTask.Timing.ConfigureSampleClock("", samplingRate,
SampleClockActiveEdge.Rising, SampleQuantityMode.ContinuousSamples, bufferLength);
analogOutputTask.Control(TaskAction.Verify);
//Create writer
analogOutputWriter = new AnalogSingleChannelWriter(analogOutputTask.Stream);
analogOutputWriter.SynchronizeCallbacks = false;
}
public void shot()
{
try
{
using (Task myTask = new Task())
{
if (checkShot())
{
myTask.AOChannels.CreateVoltageChannel("Dev1", "aoChannel",
Convert.ToDouble(-10), Convert.ToDouble(10),
AOVoltageUnits.Volts);
AnalogSingleChannelWriter writer = new AnalogSingleChannelWriter(myTask.Stream);
writer.WriteSingleSample(true, Convert.ToDouble(0));
System.Threading.Thread.Sleep(1);
writer.WriteSingleSample(true, Convert.ToDouble(5));
System.Threading.Thread.Sleep(1);
writer.WriteSingleSample(true, Convert.ToDouble(0));
shotAvailable = false;
//Timer On
// Create a timer with 2.5 sec interval.
aTimer = new System.Timers.Timer(2500);
// Hook up the Elapsed event for the timer.
aTimer.Elapsed += OnTimedEvent;
aTimer.AutoReset = false;
aTimer.Enabled = true;
}
}
}
catch (DaqException ex)
{
}
}
public void Apply_Voltage(Parameters Parameters_Instance, double voltage)
{
MainWindow.WindowInstance.Dispatcher.BeginInvoke(new MainWindow.Append_Log_Delegate(MainWindow.WindowInstance.Append_Log),
"Applling voltage " + voltage.ToString() + "\n"
);
try
{
outputTask = new Task("OutputTask");
outputTask.AOChannels.CreateVoltageChannel(Parameters_Instance.Output_Channel,
"",
Parameters_Instance.Output_Channel_MinVoltage,
Parameters_Instance.Output_Channel_MaxVoltage,
AOVoltageUnits.Volts);
outputTask.Control(TaskAction.Verify);
// TODO:: check if timing is necessary
Output_Writer_Single = new AnalogSingleChannelWriter(outputTask.Stream);
Output_Writer_Single.WriteSingleSample(true, voltage);
outputTask.Done += new TaskDoneEventHandler(Apply_Voltage_Done);
}
catch (Exception ex)
{
StopTask();
MessageBox.Show(ex.Message);
} finally
{
if (outputTask != null)
{
outputTask.Stop(); outputTask.Dispose(); outputTask = null;
}
}
}
private void bgwGetWL_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = sender as BackgroundWorker;
// Do the work (i.e. get the wavelength)
while (true)
{
if (worker.CancellationPending == true)
{
e.Cancel = true;
break;
}
else
{
Wavelength = CLGetLambdaReading(HandleBristolWavemeter);
PiezoVoltage = ReaderAI.ReadSingleSample();
if (IsLockEnabled)
{
double newPiezoVoltage = LaserLockPID.AddDataPoint(Wavelength, BristolWavemeter.Properties.Settings.Default.AcquisitionPeriod, PiezoVoltage);
using (Task myTask = new Task())
{
myTask.AOChannels.CreateVoltageChannel(string.Format("dev1/ao{0}", Properties.Settings.Default.AnalogOutputPiezo), "PiezoVoltageAO", -3, 3, AOVoltageUnits.Volts);
AnalogSingleChannelWriter myWriter = new AnalogSingleChannelWriter(myTask.Stream);
myWriter.WriteSingleSample(true, Convert.ToDouble(newPiezoVoltage));
}
IsLocked = (Math.Abs(LaserLockPID.LastWavelengthError) < Properties.Settings.Default.LockThreshold);
labelPiezoVoltage.ForeColor = (Math.Abs(newPiezoVoltage) >= 2.9) ? Color.Red : Color.Black;
}
worker.ReportProgress(5); // report 5% progress
Thread.Sleep(BristolWavemeter.Properties.Settings.Default.AcquisitionPeriod);
}
}
}
public override void AcquisitionStarting()
{
// initialise the output hardware
outputTask = new Task("analog output");
if (!Environs.Debug)
{
AnalogOutputChannel oc =
(AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels[(string)settings["channel"]];
oc.AddToTask(outputTask, oc.RangeLow, oc.RangeHigh);
writer = new AnalogSingleChannelWriter(outputTask.Stream);
writer.WriteSingleSample(true, 0);
}
scanParameter = 0;
//go gently to the correct start position
if ((string)settings["scanMode"] == "up" || (string)settings["scanMode"] == "updown")
{
if ((string)settings["flyback"] == "overshoot")
{
rampOutputToVoltage((double)settings["overshootVoltage"]);
}
rampOutputToVoltage((double)settings["start"]);
}
if ((string)settings["scanMode"] == "down" || (string)settings["scanMode"] == "downup")
{
if ((string)settings["flyback"] == "overshoot")
{
rampOutputToVoltage((double)settings["overshootVoltage"]);
}
rampOutputToVoltage((double)settings["end"]);
}
}
public override void AcquisitionStarting()
{
//connect to the hardware controller
hardwareControl = new DecelerationHardwareControl.Controller();
// initialise the output hardware, full scale -10 to 10 volts
outputTask = new Task("analog output");
if (!Environs.Debug)
{
AnalogOutputChannel oc =
(AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels[(string)settings["channel"]];
oc.AddToTask(outputTask, -10, 10);
writer = new AnalogSingleChannelWriter(outputTask.Stream);
if (!Blocked())
{
writer.WriteSingleSample(true, 0);
}
}
scanParameter = 0;
//go gently to the correct start position
if (((string)settings["scanMode"] == "up" || (string)settings["scanMode"] == "updown") && !Blocked())
{
rampOutputToVoltage((double)settings["start"]);
}
if (((string)settings["scanMode"] == "down" || (string)settings["scanMode"] == "downup") && !Blocked())
{
rampOutputToVoltage((double)settings["end"]);
}
}
/// <summary>
/// Method for outputing a voltage on the DAQ
/// </summary>
/// <param name="task">NI-DAQ output task</param>
/// <param name="voltage">Voltage to output.
/// Note must be between the limits outMax and outMin.
/// The range is limited elsewhere in the code</param>
private void SetAnalogOutput(Task task, double voltage)
{
AnalogSingleChannelWriter writer = new AnalogSingleChannelWriter(task.Stream);
writer.WriteSingleSample(true, voltage);
task.Control(TaskAction.Unreserve);
}
/// <summary>
/// Start a constant output by the DAQ device. This function starts a task named "OutputTask",
/// Don't forget to stop it when it's no longer needed.
/// </summary>
/// <param name="voltage">the requested voltage to apply</param>
public void StartConstantOutputTask(double voltage)
{
int samplesPerChannel = 2500;
int sampleRate = 2500;
//
// generate output array
//
m_functionGenerator = new FunctionGenerator(samplesPerChannel, voltage, voltage);
//
// get the properties required for the output task
//
ContinuousAOTaskProperties outputProperties = new ContinuousAOTaskProperties(null, sampleRate, samplesPerChannel, voltage);
//
// create the output task
//
m_outputTask = m_daqController.CreateContinuousAOTask(outputProperties);
//
// create the writer of the output task
//
writer = new AnalogSingleChannelWriter(m_outputTask.Stream);
//
// write static voltage
//
writer.WriteMultiSample(true, m_functionGenerator.ConstWave);
}
/// <summary>
/// Starts laser read and write tasks
/// </summary>
static void StartLaserTasks()
{
_laserWriteTask = new System.Threading.Tasks.Task(() =>
{
Task writeTask = new Task("LaserWrite");
double[] firstSamples = LaserFunction(0, _rate);
writeTask.AOChannels.CreateVoltageChannel("Dev2/AO2", "", 0, 10, AOVoltageUnits.Volts);
writeTask.Timing.ConfigureSampleClock("", _rate, SampleClockActiveEdge.Rising, SampleQuantityMode.ContinuousSamples);
writeTask.Stream.WriteRegenerationMode = WriteRegenerationMode.DoNotAllowRegeneration;
AnalogSingleChannelWriter dataWriter = new AnalogSingleChannelWriter(writeTask.Stream);
dataWriter.WriteMultiSample(false, firstSamples);
writeTask.Start();
long start_sample = _rate;
while (!_writeStop.WaitOne(100))
{
double[] samples = LaserFunction(start_sample, _rate);
if (samples == null)
{
break;
}
dataWriter.WriteMultiSample(false, samples);
start_sample += _rate;
}
writeTask.Dispose();
Task resetTask = new Task("LaserReset");
resetTask.AOChannels.CreateVoltageChannel("Dev2/AO2", "", 0, 10, AOVoltageUnits.Volts);
AnalogSingleChannelWriter resetWriter = new AnalogSingleChannelWriter(resetTask.Stream);
resetWriter.WriteSingleSample(true, 0);
resetTask.Dispose();
});
_laserReadTask = new System.Threading.Tasks.Task(() =>
{
Task read_task = new Task("laserRead");
read_task.AIChannels.CreateVoltageChannel("Dev2/ai16", "Laser", AITerminalConfiguration.Differential, -10, 10, AIVoltageUnits.Volts);
read_task.Timing.ConfigureSampleClock("", _rate, SampleClockActiveEdge.Rising, SampleQuantityMode.ContinuousSamples);
read_task.Start();
AnalogSingleChannelReader laser_reader = new AnalogSingleChannelReader(read_task.Stream);
while (!_readStop.WaitOne(10))
{
var nsamples = read_task.Stream.AvailableSamplesPerChannel;
if (nsamples >= 10)
{
double[] read = laser_reader.ReadMultiSample((int)nsamples);
lock (_laser_aiv_lock)
{
foreach (double d in read)
{
//Simple exponential smoother
_laser_aiv = 0.9 * _laser_aiv + 0.1 * d;
}
}
}
}
read_task.Dispose();
});
_laserWriteTask.Start();
_laserReadTask.Start();
}
public void setupMasterVoltageOut()
{
masterOutputTask = new Task("rampfeedback");
masterChannel = (AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels["rampfb"];
masterChannel.AddToTask(masterOutputTask, masterChannel.RangeLow, masterChannel.RangeHigh);
masterOutputTask.Control(TaskAction.Verify);
masterWriter = new AnalogSingleChannelWriter(masterOutputTask.Stream);
}
public BristolWavemeterApplication()
{
InitializeComponent();
MainThread = this;
//int dllVersion = CLGetDllVersion(); // had to change the target system to x64 (from x86) to make this work, weird (?)
HandleBristolWavemeter = CLOpenUSBSerialDevice(Properties.Settings.Default.WavemeterCOMPort); // returns a handle to the Bristol Wavemeter (CL device)
bgwGetWL.WorkerSupportsCancellation = true;
bgwGetWL.WorkerReportsProgress = true;
TaskAI = new Task();
TaskAI.AIChannels.CreateVoltageChannel(string.Format("dev1/ai{0}", Properties.Settings.Default.AnalogInputPiezo), "PiezoVoltageAI", AITerminalConfiguration.Differential, -3, 3, AIVoltageUnits.Volts);
ReaderAI = new AnalogSingleChannelReader(TaskAI.Stream);
TaskAO = new Task();
TaskAO.AOChannels.CreateVoltageChannel(string.Format("dev1/ao{0}", Properties.Settings.Default.AnalogOutputPiezo), "PiezoVoltageAO", -3, 3, AOVoltageUnits.Volts);
//TaskAO.Timing.ConfigureSampleClock("", sampleRate, SampleClockActiveEdge.Rising, SampleQuantityMode.FiniteSamples, numberOfSamples); // I'm asking for 100 Hz, it is 1000 Hz
WriterAO = new AnalogSingleChannelWriter(TaskAO.Stream);
// remoting server
ServiceHost Host;
try
{
Host = new ServiceHost(typeof(WavemeterMATLABObject), new Uri[] { new Uri(String.Format("net.tcp://localhost:{0}", Properties.Settings.Default.ServerPort)) });
Host.AddServiceEndpoint(typeof(IWavemeterMATLABObject), new NetTcpBinding(SecurityMode.None), Properties.Settings.Default.ServerName);
Host.Open();
}
catch (Exception e) { MessageBox.Show(this, e.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); }
//Data series for the chart
series1 = new System.Windows.Forms.DataVisualization.Charting.Series
{
Name = "Series1",
Color = System.Drawing.Color.Teal,
IsVisibleInLegend = false,
IsXValueIndexed = true,
ChartType = System.Windows.Forms.DataVisualization.Charting.SeriesChartType.Spline
};
chart1.Series.Add(series1);
chart1.ChartAreas[0].AxisY.Maximum = 1570;
chart1.ChartAreas[0].AxisY.Minimum = 1520;
chart1.ChartAreas[0].AxisY.LabelStyle.Format = "###0.0000";
//Setup the PID controller and interface
LaserLockPID = new WavemeterPID();
LaserLockPID.G = Properties.Settings.Default.G;
numericUpDownPIDGain.Value = Convert.ToDecimal(Properties.Settings.Default.G);
LaserLockPID.Kp = Properties.Settings.Default.Kp;
numericUpDownPIDProportional.Value = Convert.ToDecimal(Properties.Settings.Default.Kp);
LaserLockPID.Kd = Properties.Settings.Default.Kd;
numericUpDownPIDDerivative.Value = Convert.ToDecimal(Properties.Settings.Default.Kd);
LaserLockPID.Ki = Properties.Settings.Default.Ki;
numericUpDownPIDIntegral.Value = Convert.ToDecimal(Properties.Settings.Default.Ki);
//System.Media.SoundPlayer mySoundPlayer = new System.Media.SoundPlayer(LINQS.BristolWavemeter.Properties.Resources.LINQStartupSound);
//mySoundPlayer.Play();
}
public void ConfigureCavityScan(int numberOfSteps, bool autostart)
{
outputCavityTask = new Task("CavityPiezoVoltage");
cavityChannel =
(AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels[cavityChannelName];
cavityChannel.AddToTask(outputCavityTask, 0, 10);
outputCavityTask.Control(TaskAction.Verify);
cavityWriter = new AnalogSingleChannelWriter(outputCavityTask.Stream);
}
public void ConfigureCavityScan(int numberOfSteps, bool autostart)
{
outputCavityTask = new Task("CavityPiezoVoltage");
cavityChannel =
(AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels[cavityChannelName];
cavityChannel.AddToTask(outputCavityTask, 0, 10);
outputCavityTask.Control(TaskAction.Verify);
cavityWriter = new AnalogSingleChannelWriter(outputCavityTask.Stream);
}
public int WriteAnalogChannel(string lines, string name, int freq, int samples, int cycles, string sigtype, double ampl, double min, double max)
{
int res = 0;
Task analogWriteTask = new Task();
AOChannel ch;
if (max == 0)
{
max = 10;
}
try
{
// Create the task and channel
//myTask = New Task()
ch = analogWriteTask.AOChannels.CreateVoltageChannel(lines, "", min, max, AOVoltageUnits.Volts);
// Verify the task before doing the waveform calculations
analogWriteTask.Control(TaskAction.Verify);
// Calculate some waveform parameters and generate data
//Dim fGen As New FunctionGenerator( _
// analogWriteTask.Timing, _
// freq.ToString, _
// samples.ToString, _
// cycles.ToString, _
// sigtype, _
// ampl.ToString)
//Configure the sample clock with the calculated rate
//analogWriteTask.Timing.ConfigureSampleClock( _
// "", _
// fGen.ResultingSampleClockRate, _
// SampleClockActiveEdge.Rising, _
// SampleQuantityMode.ContinuousSamples, 1000)
// Write the data to the buffer
AnalogSingleChannelWriter writer = new AnalogSingleChannelWriter(analogWriteTask.Stream);
//writer.WriteMultiSample(False, fGen.Data)
//Dim res As IAsyncResult
//res = writer.BeginWriteMultiSample(False, fGen.Data, AddressOf _WriteAnalogChannelComplete, 0)
analogWriteTask.Start();
writer.WriteSingleSample(false, 2.5);
//Start writing out data
//analogWriteTask.Start()
analogWriteTask.Stop();
}
catch (DaqException ex) {
DaqError(ex.Message);
res = -1;
}
finally {
analogWriteTask.Dispose();
}
return(res);
}
public void RunDAQ()
{
DigitalEdgeStartTriggerEdge triggerEdge = DigitalEdgeStartTriggerEdge.Rising;
try
{
string s = string.Empty;
s = _name == "/ai1" ? "etalon" : "measured";
inputTask = new NationalInstruments.DAQmx.Task(s);
outputTask = new NationalInstruments.DAQmx.Task(s + "_output");
inputTask.AIChannels.CreateVoltageChannel(sInputName, "", AITerminalConfiguration.Pseudodifferential, inputDAQMinValue, inputDAQMaxValue, AIVoltageUnits.Volts);
outputTask.AOChannels.CreateVoltageChannel(sOutputName, "", outputDAQMinValue, outputDAQMaxValue, AOVoltageUnits.Volts);
inputTask.Timing.ConfigureSampleClock("", dRateIO, SampleClockActiveEdge.Rising, SampleQuantityMode.ContinuousSamples, iInputOutputSamples);
outputTask.Timing.ConfigureSampleClock("", dRateIO, SampleClockActiveEdge.Rising, SampleQuantityMode.ContinuousSamples, iInputOutputSamples);
outputTask.Triggers.StartTrigger.ConfigureDigitalEdgeTrigger(terminalNameBase + "ai/StartTrigger", triggerEdge);
inputTask.Control(TaskAction.Verify);
outputTask.Control(TaskAction.Verify);
outputData = fGen.Data;
writer = new AnalogSingleChannelWriter(outputTask.Stream);
writer.WriteMultiSample(false, outputData);
StartTask();
outputTask.Start();
inputTask.Start();
//inputCallback = new AsyncCallback(InputReady);
reader = new AnalogSingleChannelReader(inputTask.Stream);
//------------ТЕСТОВЫЙ КУСОК------------ ЧТЕНИЕ В ЭТОМ ЖЕ ПОТОКЕ--
double[] data = reader.ReadMultiSample(iInputOutputSamples);
BufReadDAQReceived?.Invoke(data);
StopTask();
//----------------------------------------------------------------
/*// Use SynchronizeCallbacks to specify that the object
* // marshals callbacks across threads appropriately.
* reader.SynchronizeCallbacks = bSynchronizeCallbacks;
*
* reader.BeginReadMultiSample(iInputOutputSamples, inputCallback, inputTask);*/
}
catch (Exception ex)
{
StopTask();
WarningDAQUpdate?.Invoke(ex.Message);
}
}
public TemperatureController(double timeStep, string tempUnits, string aiChannel, AIVoltageUnits aiUnits, string aoChannel, AOVoltageUnits aoUnits) : base(timeStep)
{
sensor = new TempSensor(aiChannel, aiUnits, tempUnits);
writeTask = new NationalInstruments.DAQmx.Task();
writer = new AnalogSingleChannelWriter(writeTask.Stream);
writeTask.AOChannels.CreateVoltageChannel(aoChannel, "", -10.0, 10.0, aoUnits);
sensor.TemperatureCoefficient = 0.01; //temperature controller inherently contains a temp sensor with 0.01mV/K coefficient
}
private void configureAnalogOutput()
{
analogOutputTask = new Task("phase lock analog output");
AnalogOutputChannel outputChannel =
(AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels["phaseLockAnalogOutput"];
outputChannel.AddToTask(analogOutputTask, VCO_LOW, VCO_HIGH);
analogWriter = new AnalogSingleChannelWriter(analogOutputTask.Stream);
analogWriter.WriteSingleSample(true, VCO_CENTRAL); // start out with the central value
}
public override void AcquisitionStarting()
{
if (!Environs.Debug)
{
analogTask = new Task(Channel);
((AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels[Channel]).AddToTask(analogTask, 0, 5);
analogTask.Control(TaskAction.Verify);
writer = new AnalogSingleChannelWriter(analogTask.Stream);
}
}
//set Analog AO0 - voltage level
public void set_voltage_AO(double volt_AO)
{
using (Task myTask = new Task())
{
AOChannel myAOChannel;
myAOChannel = myTask.AOChannels.CreateVoltageChannel("dev1/ao0", "myAOChannel", 0, 5, AOVoltageUnits.Volts);
AnalogSingleChannelWriter writer = new AnalogSingleChannelWriter(myTask.Stream);
writer.WriteSingleSample(true, volt_AO);
}
}
public override void AcquisitionStarting()
{
if (!Environs.Debug)
{
analogTask = new Task(Channel);
((AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels[Channel]).AddToTask(analogTask, 0, 5);
analogTask.Control(TaskAction.Verify);
writer = new AnalogSingleChannelWriter(analogTask.Stream);
}
}
//This takes in a voltage. A bit cheezy, but I needed the laser
// voltage to be set as soon value as soon as it gets configured.
public void ConfigureSetLaserVoltage(double voltage)
{
outputLaserTask = new Task("FeedbackToLaser" + laserChannelName);
laserChannel =
(AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels[laserChannelName];
laserChannel.AddToTask(outputLaserTask, laserChannel.RangeLow, laserChannel.RangeHigh);
outputLaserTask.Control(TaskAction.Verify);
laserWriter = new AnalogSingleChannelWriter(outputLaserTask.Stream);
laserWriter.WriteSingleSample(true, voltage);
//outputLaserTask.Start();
}
public DaqAo(string channel)
{
_myAoChannel = _analogOutTask.AOChannels.CreateVoltageChannel(
"dev3/" + channel,
"myAOChannel",
0,
5,
AOVoltageUnits.Volts
);
_writer = new AnalogSingleChannelWriter(_analogOutTask.Stream);
}
//This takes in a voltage. A bit cheezy, but I needed the laser
// voltage to be set as soon value as soon as it gets configured.
public void ConfigureSetLaserVoltage(double voltage)
{
outputLaserTask = new Task("FeedbackToLaser");
laserChannel =
(AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels[laserChannelName];
laserChannel.AddToTask(outputLaserTask, -10, 10);
outputLaserTask.Control(TaskAction.Verify);
laserWriter = new AnalogSingleChannelWriter(outputLaserTask.Stream);
laserWriter.WriteSingleSample(true, voltage);
outputLaserTask.Start();
}
private static void WriteAnalog(Task task, double voltage)
{
if (disposed)
{
return;
}
AnalogSingleChannelWriter write = new AnalogSingleChannelWriter(task.Stream);
write.BeginWriteSingleSample(true, voltage, null, null);
}
public void SetValue(double analogDataOut)
{
Task analogOutTask = new Task();
AOChannel myAOChannel;
myAOChannel = analogOutTask.AOChannels.CreateVoltageChannel("dev31/ao0", "myAOChannel", 0, 5, AOVoltageUnits.Volts);
AnalogSingleChannelWriter writer = new
AnalogSingleChannelWriter(analogOutTask.Stream);
writer.WriteSingleSample(true, analogDataOut);
}
public SDLPS500Controller(string device, string aoName)
{
_controlOutput = 0;
_powerCashValid = true;
_powerCashed = 0;
//Set up task and channel writer
_aoTask = new Task("LaserOutput");
_aoTask.AOChannels.CreateVoltageChannel(device + "/" + aoName, "LasOut", 0, 5, AOVoltageUnits.Volts);
_aoWriter = new AnalogSingleChannelWriter(_aoTask.Stream);
//Set output to 0
_aoWriter.WriteSingleSample(true, 0);
}
public void SetGain(double gain)
{
var niTask = new NationalInstruments.DAQmx.Task();
var analogOutput = niTask.AOChannels.CreateVoltageChannel(
"Dev8/ao0",
"SetGain",
0,
5,
AOVoltageUnits.Volts
);
var writer = new AnalogSingleChannelWriter(niTask.Stream);
writer.WriteSingleSample(true, gain);
}
public void SetSetPoint(double temperature)
{
var gain = PlantCalculations.CalcTemperatureToVolt(temperature);
var niTask = new NationalInstruments.DAQmx.Task();
var analogOutput = niTask.AOChannels.CreateVoltageChannel(
"Dev9/ao1",
"SV",
1,
5,
AOVoltageUnits.Volts
);
var writer = new AnalogSingleChannelWriter(niTask.Stream);
writer.WriteSingleSample(true, Math.Min(Math.Max(gain, 1), 5));
}
public override void TryInitialize()
{
try
{
_daqTask.AOChannels.CreateVoltageChannel(PhysicalChannelName, nameToAssignChannel: PhysicalChannelName,
minimumValue, maximumValue, units);
DaqStream stream = _daqTask.Stream ?? throw new DaqException(Constants.ErrorMessages.INVALID_STREAM);
_writer = new AnalogSingleChannelWriter(stream);
this.IsInitialized = true;
}
catch (DaqException ex)
{
Stop(ex);
}
}
/// <summary>
/// Включение постоянной генерации сигнала. Чтение и контроль ошибок при этом производится в CALLBACK. Для завершения генерации используй метод StopDAQGeneration()
/// </summary>
public void RunDAQGeneration()
{
DigitalEdgeStartTriggerEdge triggerEdge = DigitalEdgeStartTriggerEdge.Rising;
try
{
string s = string.Empty;
s = _name == "/ai1" ? "etalon" : "measured";
inputTask = new NationalInstruments.DAQmx.Task(s);
outputTask = new NationalInstruments.DAQmx.Task(s + "_output");
inputTask.AIChannels.CreateVoltageChannel(sInputName, "", AITerminalConfiguration.Pseudodifferential, inputDAQMinValue, inputDAQMaxValue, AIVoltageUnits.Volts);
outputTask.AOChannels.CreateVoltageChannel(sOutputName, "", outputDAQMinValue, outputDAQMaxValue, AOVoltageUnits.Volts);
inputTask.Timing.ConfigureSampleClock("", dRateIO, SampleClockActiveEdge.Rising, SampleQuantityMode.ContinuousSamples, iInputOutputSamples);
outputTask.Timing.ConfigureSampleClock("", dRateIO, SampleClockActiveEdge.Rising, SampleQuantityMode.ContinuousSamples, iInputOutputSamples);
outputTask.Triggers.StartTrigger.ConfigureDigitalEdgeTrigger(terminalNameBase + "ai/StartTrigger", triggerEdge);
inputTask.Control(TaskAction.Verify);
outputTask.Control(TaskAction.Verify);
outputData = fGen.Data;
writer = new AnalogSingleChannelWriter(outputTask.Stream);
writer.WriteMultiSample(false, outputData);
StartTask();
outputTask.Start();
//inputTask.Start();
inputCallback = new AsyncCallback(AnalogInCallback);
reader = new AnalogSingleChannelReader(inputTask.Stream);
reader.SynchronizeCallbacks = true;
//reader.BeginReadMultiSample(iInputOutputSamples, inputCallback, inputTask);
reader.BeginReadWaveform(iInputOutputSamples, inputCallback, inputTask);
//statusDAQtimer.Enabled = true;
}
catch (Exception ex)
{
StopTask();
WarningDAQUpdate?.Invoke(ex.Message);
}
}
public AnalogOutputWriter(int channel, double minVoltage, double maxVoltage)
{
try
{
myTask.AOChannels.CreateVoltageChannel(aoChannels[channel], "GenCurrent", minVoltage, maxVoltage, AOVoltageUnits.Volts);
myChannelWriter = new AnalogSingleChannelWriter(myTask.Stream);
}
catch (Exception exception)
{
if (MessageBox.Show("Can't connect to USB-DAQ. Continue? ", "Error", MessageBoxButtons.OKCancel, MessageBoxIcon.Error) == DialogResult.Cancel)
{
Environment.Exit(0);
}
}
}
//아날로그 출력 연결
public void Connect_Output(ref string ErrorMsg)
{
try
{
Writetask.AOChannels.CreateVoltageChannel(ini.GetIniValue("NI", "Name") + "/ao0", "Analog Output", -10, 10, AOVoltageUnits.Volts);
writer = new AnalogSingleChannelWriter(Writetask.Stream);
Writetask.Control(TaskAction.Verify);
}
catch (DaqException de)
{
ErrorMsg = de.Message;
}
catch (Exception e)
{
ErrorMsg = e.Message;
}
}
public void Start()
{
analogsAvailable = true;
// all the analog outputs are unblocked at the outset
analogOutputsBlocked = new Hashtable();
foreach (DictionaryEntry de in Environs.Hardware.AnalogOutputChannels)
{
analogOutputsBlocked.Add(de.Key, false);
}
aomChannel.AddToTask(outputTask, -10, 10);
outputTask.Control(TaskAction.Verify);
aomWriter = new AnalogSingleChannelWriter(outputTask.Stream);
window = new ControlWindow();
window.controller = this;
Application.Run(window);
}
public AnalogOutputWriter(int channel, double minVoltage, double maxVoltage)
{
try
{
myTask.AOChannels.CreateVoltageChannel(aoChannels[channel], "GenCurrent", minVoltage, maxVoltage, AOVoltageUnits.Volts);
myChannelWriter = new AnalogSingleChannelWriter(myTask.Stream);
}
catch (Exception exception)
{
if (MessageBox.Show("Can't connect to USB-DAQ. Continue? ", "Error", MessageBoxButtons.OKCancel, MessageBoxIcon.Error) == DialogResult.Cancel)
{
Environment.Exit(0);
}
}
}
private void btnWriteAnalogOut_Click(object sender, EventArgs e)
{
Task analogOutTask = new Task();
AOChannel myAOChannel;
myAOChannel = analogOutTask.AOChannels.CreateVoltageChannel("dev1/ao0", "myAOChannel", 0, 5, AOVoltageUnits.Volts);
AnalogSingleChannelWriter writer = new AnalogSingleChannelWriter(analogOutTask.Stream);
double analogDataOut;
analogDataOut = Convert.ToDouble(txtAnalogOut.Text);
writer.WriteSingleSample(true, analogDataOut);
// kullanacaðýmýz zaman
Form1 nesne1 = new Form1();
}
public void ConfigureCavityScan(int numberOfSteps, bool autostart)
{
outputCavityTask = new Task("CavityPiezoVoltage");
cavityChannel =
(AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels[cavityChannelName];
cavityChannel.AddToTask(outputCavityTask, 0, 10);
outputCavityTask.AOChannels[0].DataTransferMechanism = AODataTransferMechanism.Dma;
if (!autostart)
{
outputCavityTask.Timing.ConfigureSampleClock("", 500,
SampleClockActiveEdge.Rising, SampleQuantityMode.FiniteSamples, 2 * numberOfSteps);
outputCavityTask.Triggers.StartTrigger.ConfigureDigitalEdgeTrigger(
(string)Environs.Hardware.GetInfo(cavityTriggerInputName), DigitalEdgeStartTriggerEdge.Rising);
}
outputCavityTask.Control(TaskAction.Verify);
cavityWriter = new AnalogSingleChannelWriter(outputCavityTask.Stream);
}
public override void AcquisitionStarting()
{
//connect to the hardware controller
hardwareControl = new DecelerationHardwareControl.Controller();
// initialise the output hardware, full scale -10 to 10 volts
outputTask = new Task("analog output");
if (!Environs.Debug)
{
AnalogOutputChannel oc =
(AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels[(string)settings["channel"]];
oc.AddToTask(outputTask, -10, 10);
writer = new AnalogSingleChannelWriter(outputTask.Stream);
if (!Blocked()) writer.WriteSingleSample(true, 0);
}
scanParameter = 0;
//go gently to the correct start position
if (((string)settings["scanMode"] == "up" || (string)settings["scanMode"] == "updown") && !Blocked())
rampOutputToVoltage((double)settings["start"]);
if (((string)settings["scanMode"] == "down" || (string)settings["scanMode"] == "downup") && !Blocked())
rampOutputToVoltage((double)settings["end"]);
}
internal ChannelOutput(double samplingRate, double outputRefreshTime, double inputRefreshTime, Task spikeTask, String NIDevice, int NIChannel)
{
//Compute buffer length, instantiate buffer
int multiple = (int)(Math.Round(outputRefreshTime / inputRefreshTime)); //Get number of input buffer reads that approximate the desired output rate
if (multiple < 1) multiple = 1; //Ensure the multiple is at least 1
int bufferLength = (int)((double)multiple * inputRefreshTime * samplingRate); //Calculate length
buffer = new double[bufferLength];
//Create new task
analogOutputTask = new Task("Playback Analog Output Task");
analogOutputTask.AOChannels.CreateVoltageChannel(NIDevice + "/ao" + NIChannel, "",
-10.0, 10.0, AOVoltageUnits.Volts);
analogOutputTask.Timing.ReferenceClockSource = spikeTask.Timing.ReferenceClockSource;
analogOutputTask.Timing.ReferenceClockRate = spikeTask.Timing.ReferenceClockRate;
analogOutputTask.Timing.ConfigureSampleClock("", samplingRate,
SampleClockActiveEdge.Rising, SampleQuantityMode.ContinuousSamples, bufferLength);
analogOutputTask.Control(TaskAction.Verify);
//Create writer
analogOutputWriter = new AnalogSingleChannelWriter(analogOutputTask.Stream);
analogOutputWriter.SynchronizeCallbacks = false;
}
public void Start()
{
analogsAvailable = true;
// all the analog outputs are unblocked at the outset
analogOutputsBlocked = new Hashtable();
foreach (DictionaryEntry de in Environs.Hardware.AnalogOutputChannels)
analogOutputsBlocked.Add(de.Key, false);
aomChannel.AddToTask(outputTask, -10, 10);
outputTask.Control(TaskAction.Verify);
aomWriter = new AnalogSingleChannelWriter(outputTask.Stream);
window = new ControlWindow();
window.controller = this;
Application.Run(window);
}
//Overload for using a calibration before outputting to hardware
public void SetAnalogOutput(string channelName, double voltage, bool useCalibration)
{
AnalogSingleChannelWriter writer = new AnalogSingleChannelWriter(analogTasks[channelName].Stream);
double output;
if (useCalibration)
{
try
{
output = ((Calibration)calibrations[channelName]).Convert(voltage);
}
catch (DAQ.HAL.Calibration.CalibrationRangeException)
{
MessageBox.Show("The number you have typed is out of the calibrated range! \n Try typing something more sensible.");
throw new CalibrationException();
}
catch
{
MessageBox.Show("Calibration error");
throw new CalibrationException();
}
}
else
{
output = voltage;
}
try
{
writer.WriteSingleSample(true, output);
analogTasks[channelName].Control(TaskAction.Unreserve);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
private void configureAnalogOutput()
{
analogOutputTask = new Task("phase lock analog output");
AnalogOutputChannel outputChannel =
(AnalogOutputChannel) Environs.Hardware.AnalogOutputChannels["phaseLockAnalogOutput"];
outputChannel.AddToTask(analogOutputTask, VCO_LOW, VCO_HIGH);
analogWriter = new AnalogSingleChannelWriter(analogOutputTask.Stream);
analogWriter.WriteSingleSample(true, VCO_CENTRAL); // start out with the central value
}
public void setupMasterVoltageOut()
{
masterOutputTask = new Task("rampfeedback");
masterChannel=(AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels["rampfb"];
masterChannel.AddToTask(masterOutputTask, masterChannel.RangeLow, masterChannel.RangeHigh);
masterOutputTask.Control(TaskAction.Verify);
masterWriter = new AnalogSingleChannelWriter(masterOutputTask.Stream);
}
/// <summary>
/// Initiate the output task writer, and apply an initial constant bias
/// </summary>
/// <param name="task">The output task that the writer will belong to</param>
/// <param name="settings">The UI settings</param>
private void InitiateOutputWriter(Task task, IVSettings settings)
{
//
// generate output arrays
//
m_functionGenerator = new FunctionGenerator(settings.IVGeneralSettings.SamplesPerCycle,
settings.IVGeneralSettings.VoltageAmplitude,
settings.IVGeneralSettings.VoltageAmplitude);
//
// create the writer of the output task
//
writer = new AnalogSingleChannelWriter(m_outputTask.Stream);
//
// write static voltage
//
writer.WriteMultiSample(true, m_functionGenerator.ConstWave);
}
private void WriteSingleAnalog(NIDAQOutputStream stream, double value)
{
using (var t = new DAQTask())
{
t.AOChannels.CreateVoltageChannel(stream.PhysicalName, "", Device.AOVoltageRanges.Min(),
Device.AOVoltageRanges.Max(), AOVoltageUnits.Volts);
var writer = new AnalogSingleChannelWriter(t.Stream);
writer.WriteSingleSample(true, value);
}
}
public void SetAnalogOutput(string channel, double value, bool useCalibration)
{
analogWriter = new AnalogSingleChannelWriter(analogTasks[channel].Stream);
bool changeIt = true;
double output = 0.0;
if (useCalibration)
{
try
{
output = ((Calibration)calibrations[channel]).Convert(value);
}
catch (DAQ.HAL.Calibration.CalibrationRangeException)
{
MessageBox.Show("The number is outside the calibrated range. The value will not be updated.");
changeIt = false;
}
catch
{
MessageBox.Show("Calibration error");
changeIt = false;
}
}
else
{
output = value;
}
if (changeIt)
{
try
{
analogWriter.WriteSingleSample(true, output);
analogTasks[channel].Control(TaskAction.Unreserve);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
}
public void Start()
{
proportionalGain = 0;
integralGain = 0;
// derivativeGain = 0;
ui = new MainForm();
ui.controller = this;
// get access to ScanMaster and the DecelerationHardwareController
RemotingHelper.ConnectScanMaster();
RemotingHelper.ConnectDecelerationHardwareControl();
scanMaster = new ScanMaster.Controller();
hardwareControl = new DecelerationHardwareControl.Controller();
fitter = new DAQ.Analyze.GaussianFitter();
if (!Environs.Debug)
{
outputTask = new Task("LaserControllerOutput");
laserChannel =
(AnalogOutputChannel)Environs.Hardware.AnalogOutputChannels["laser"];
laserChannel.AddToTask(outputTask, -10, 10);
outputTask.Control(TaskAction.Verify);
laserWriter = new AnalogSingleChannelWriter(outputTask.Stream);
inputTask = new Task("LaserControllerInput");
cavityChannel = (AnalogInputChannel)Environs.Hardware.AnalogInputChannels["lockcavity"];
cavityChannel.AddToTask(inputTask, -10, 10);
cavityReader = new AnalogSingleChannelReader(inputTask.Stream);
inputrefTask = new Task("ReferenceLaserControllerInput");
cavityrefChannel = (AnalogInputChannel)Environs.Hardware.AnalogInputChannels["refcavity"];
cavityrefChannel.AddToTask(inputrefTask, -10, 10);
cavityrefReader = new AnalogSingleChannelReader(inputrefTask.Stream);
}
timerDelegate = new TimerCallback(TalkToHardwareControl);
hardwareControlTimer = new System.Threading.Timer(timerDelegate, null, 5000, HARDWARE_CONTROL_TALK_PERIOD);
Application.Run(ui);
}
public void Start()
{
flowChannel.AddToTask(outputTask, 0, 5);
outputTask.Control(TaskAction.Verify);
flowWriter = new AnalogSingleChannelWriter(outputTask.Stream);
flowmeterChannel.AddToTask(inputTask, 0, 5);
inputTask.Control(TaskAction.Verify);
flowReader = new AnalogSingleChannelReader(inputTask.Stream);
// make the control window
window = new ControlWindow();
window.controller = this;
Application.Run(window);
}
/// <summary>
/// Method for outputing a voltage on the DAQ
/// </summary>
/// <param name="task">NI-DAQ output task</param>
/// <param name="voltage">Voltage to output.
/// Note must be between the limits outMax and outMin.
/// The range is limited elsewhere in the code</param>
private void SetAnalogOutput(Task task, double voltage)
{
AnalogSingleChannelWriter writer = new AnalogSingleChannelWriter(task.Stream);
writer.WriteSingleSample(true, voltage);
task.Control(TaskAction.Unreserve);
}
// ---------------ZAPIS ANALOG-----------
/// <summary>
/// Metoda nastavuje/zapisuje cez AD prevodnik hodnotu value.
/// </summary>
/// <param name="value"></param>
public void setAnalogOutput(double value)
{
Task analogOutTask = new Task();
AOChannel myAOChannel;
myAOChannel = analogOutTask.AOChannels.CreateVoltageChannel(
prevodnikId + "/ao1",
"myAOChannel",
0,
5,
AOVoltageUnits.Volts
);
AnalogSingleChannelWriter writer = new AnalogSingleChannelWriter(analogOutTask.Stream);
writer.WriteSingleSample(true, value);
}
