private void EmitLogicalDeviceToGrid(HardwareChannel.HardwareConstants.ChannelTypes ct, int logicalID, LogicalChannel lc)
{
string[] row = { ct.ToString(),
logicalID.ToString(),
lc.Name,
lc.Description,
lc.HardwareChannel.ToString() };
logicalDevicesDataGridView.Rows.Add(row);
}
public bool generateBuffer(SequenceData sequence, DeviceSettings deviceSettings, HardwareChannel hc, int logicalChannelID, List<GpibRampCommandConverter> commandConverters)
{
this.logicalChannelID = logicalChannelID;
this.deviceType = hc.GpibDeviceType;
commandBuffer = new List<GpibCommand>();
if (deviceSettings.StartTriggerType != DeviceSettings.TriggerType.SoftwareTrigger)
{
throw new Exception("GPIB devices must have a software start trigger.");
}
// start by adding the initialization string to the command buffer
// this does nothing for unknown device types
// Modified by REO 11/25/08: Null strings produce errors if written to device, so check
if(HardwareChannel.HardwareConstants.gpibInitializationCommands[(int)deviceType]!= null)
commandBuffer.Add(new GpibCommand(HardwareChannel.HardwareConstants.gpibInitializationCommands[(int)deviceType], 0));
if (deviceType == HardwareChannel.HardwareConstants.GPIBDeviceType.Unknown)
{
foreach (GpibRampCommandConverter conv in commandConverters)
{
//Modified by REO 11/25/08: Null strings produce errors if written to device, so check
if (deviceSettings.DeviceDescription.Contains(conv.DeviceIdentifierSubstring) && conv.InitializationCommand != null)
commandBuffer.Add(new GpibCommand(AddNewlineCharacters(conv.InitializationCommand), 0));
}
}
int currentStepIndex = - 1;
//measured in ticks. 1 tick = 100 ns.
long currentTime = 0;
// This functionality is sort of somewhat duplicated in sequencedata.generatebuffers. It would be good
// to come up with a more coherent framework to do these sorts of operations.
while (true)
{
currentStepIndex++;
if (currentStepIndex >= sequence.TimeSteps.Count)
break;
TimeStep currentStep = sequence.TimeSteps[currentStepIndex];
if (!currentStep.StepEnabled)
continue;
if (currentStep.GpibGroup == null || !currentStep.GpibGroup.channelEnabled(logicalChannelID))
{
currentTime += seconds_to_ticks(currentStep.StepDuration.getBaseValue());
continue;
}
// determine the index of the next step in which this channel has an action
int nextEnabledStepIndex = sequence.findNextGpibChannelEnabledTimestep(currentStepIndex, logicalChannelID);
long groupDuration = seconds_to_ticks(sequence.timeBetweenSteps(currentStepIndex, nextEnabledStepIndex));
// now take action:
GPIBGroupChannelData channelData = currentStep.GpibGroup.getChannelData(logicalChannelID);
if (channelData.DataType == GPIBGroupChannelData.GpibChannelDataType.raw_string) {
// Raw string commands just get added
string stringWithCorrectNewlines = AddNewlineCharacters(channelData.RawString);
commandBuffer.Add(new GpibCommand( stringWithCorrectNewlines, currentTime));
}
else if (channelData.DataType == GPIBGroupChannelData.GpibChannelDataType.voltage_frequency_waveform)
{
GpibRampCommandConverter rampConverter = null;
switch (hc.GpibDeviceType)
{
case HardwareChannel.HardwareConstants.GPIBDeviceType.Unknown:
{
foreach (GpibRampCommandConverter conv in commandConverters)
{
if (deviceSettings.DeviceDescription.Contains(conv.DeviceIdentifierSubstring))
rampConverter = conv;
}
if (rampConverter == null)
{
throw new Exception("Voltage/frequency ramp not supported for unknown gpib device " + hc.ToString() + ".");
}
}
break;
case HardwareChannel.HardwareConstants.GPIBDeviceType.Agilent_ESG_SIG_Generator:
{
rampConverter = ESG_SeriesRampConverter;
}
break;
}
double[] amplitudeArray;
double[] frequencyArray;
// get amplitude and frequency value arrays
int nSamples = (int)(ticks_to_seconds(groupDuration) * (double)deviceSettings.SampleClockRate);
double secondsPerSample = ticks_to_seconds(groupDuration) / (double) nSamples;
amplitudeArray = channelData.volts.getInterpolation(nSamples, 0, ticks_to_seconds(groupDuration), sequence.Variables, sequence.CommonWaveforms);
frequencyArray = channelData.frequency.getInterpolation(nSamples, 0, ticks_to_seconds(groupDuration), sequence.Variables, sequence.CommonWaveforms);
List<DoubleIntPair> amplitudeIndexPairs = ConvertArrayToIndexValuePairs(amplitudeArray);
List<DoubleIntPair> frequencyIndexPairs = ConvertArrayToIndexValuePairs(frequencyArray);
int amplitudeIndex = 0;
int frequencyIndex = 0;
for (int i = 0; i < nSamples; i++)
{
bool amplitudeMatch = false;
bool frequencyMatch = false;
// determine if there is either a amplitude or frequency data point for this sample number
if (amplitudeIndex < amplitudeIndexPairs.Count)
amplitudeMatch = amplitudeIndexPairs[amplitudeIndex].myInt == i;
if (frequencyIndex < frequencyIndexPairs.Count)
frequencyMatch = frequencyIndexPairs[frequencyIndex].myInt == i;
if (amplitudeIndex >= amplitudeIndexPairs.Count && frequencyIndex >= frequencyIndexPairs.Count)
break;
if (amplitudeMatch || frequencyMatch)
{
string command = "";
if (amplitudeMatch)
{
command += rampConverter.amplitudeCommand(amplitudeIndexPairs[amplitudeIndex].myDouble);
amplitudeIndex++;
}
if (frequencyMatch)
{
command += rampConverter.frequencyCommand(frequencyIndexPairs[frequencyIndex].myDouble);
frequencyIndex++;
}
long commandTime = currentTime + seconds_to_ticks((double)i * secondsPerSample);
commandBuffer.Add(new GpibCommand(command, commandTime));
}
}
}
else if (channelData.DataType == GPIBGroupChannelData.GpibChannelDataType.string_param_string)
{
if (channelData.StringParameterStrings != null)
{
foreach (StringParameterString sps in channelData.StringParameterStrings)
{
string commandWithCorrectNewlines = AddNewlineCharacters(sps.ToString());
commandBuffer.Add(new GpibCommand(commandWithCorrectNewlines, currentTime));
}
}
}
currentTime += seconds_to_ticks(currentStep.StepDuration.getBaseValue());
}
return true;
}
