/// <summary> /// Creates a task for a variable timebase output. Consumes the entire port (8 bits) that the timebase is on. (ie outputs the /// signal on all 8 bits /// </summary> /// <param name="channelName"></param> /// <param name="masterFrequency"></param> /// <param name="sequenceData"></param> /// <param name="timebaseType"></param> /// <returns></returns> public static Task createDaqMxVariableTimebaseSource(string channelName, int masterFrequency, SequenceData sequenceData, SequenceData.VariableTimebaseTypes timebaseType, ServerSettings serverSettings, DeviceSettings deviceSettings) { Task task = new Task("Variable timebase output task"); TimestepTimebaseSegmentCollection timebaseSegments = sequenceData.generateVariableTimebaseSegments(timebaseType, Common.getPeriodFromFrequency(masterFrequency)); bool [] buffer = sequenceData.getVariableTimebaseClock(timebaseSegments); string timebaseDeviceName = HardwareChannel.parseDeviceNameStringFromPhysicalChannelString(channelName); string timebasePort = HardwareChannel.parsePortStringFromChannelString(channelName); task.DOChannels.CreateChannel(timebasePort, "", ChannelLineGrouping.OneChannelForAllLines); task.Timing.ConfigureSampleClock("", (double)masterFrequency, deviceSettings.ClockEdge, SampleQuantityMode.FiniteSamples, buffer.Length); if (serverSettings.VariableTimebaseTriggerInput != "") { task.Triggers.StartTrigger.ConfigureDigitalEdgeTrigger(serverSettings.VariableTimebaseTriggerInput, DigitalEdgeStartTriggerEdge.Rising); } DigitalSingleChannelWriter writer = new DigitalSingleChannelWriter(task.Stream); byte[] byteBuffer = new byte[buffer.Length]; for (int j = 0; j < buffer.Length; j++) { if (buffer[j]) { byteBuffer[j] = 255; } } writer.WriteMultiSamplePort(false, byteBuffer); return(task); }
/// <summary> /// This method is a sort of combination of createDaqMxVariableTimebaseSource and createDaqMxTask. It is intended /// for use to create a digital output task that has both a variable timebase source on it, without having to discard /// all of the other channels on that port (and possibly on its neighboring port). /// /// NOTE: No longer true. This function can not create the variable timebase outputs at the same time as /// normal outputs. If you attempt to use digital outputs on the same half of the card as your variable timebase output, /// this method will complain. /// </summary> /// <param name="channelName"> /// Name of the channel that will output the variable timebase clock. /// </param> /// <param name="portsToUse"> /// A list of integers specifying the digital ports that this task will use. The task will automatically /// make use of the full port that the variable timebase clock belongs to. If portsToUse is null, then /// this function will automatically use both this port and its neighboring port (0 with 1, 2 with 3, etc). /// The rationale for this is that on some NI devices, these pairs of ports will share a sample clock and /// cannot truly be used independently. /// </param> /// <param name="masterFrequency"> /// The frequency, in hertz, of the master clock which will drive the variable timebase clock and the rest of the /// channels in this task. /// </param> /// <param name="sequenceData"></param> /// <param name="timebaseType"></param> /// <param name="deviceName"></param> /// <param name="deviceSettings"></param> /// <param name="sequence"></param> /// <param name="settings"></param> /// <param name="usedDigitalChannels"></param> /// <param name="usedAnalogChannels"></param> /// <param name="serverSettings"></param> /// <returns></returns> public static Task createDaqMxDigitalOutputAndVariableTimebaseSource(string channelName, List <int> portsToUse, int masterFrequency, SequenceData sequenceData, SequenceData.VariableTimebaseTypes timebaseType, string deviceName, DeviceSettings deviceSettings, SettingsData settings, Dictionary <int, HardwareChannel> usedDigitalChannels, ServerSettings serverSettings) { // First generate the variable timebase buffer. We will need stuff like its length for configuring the task, which is why we do this first. TimestepTimebaseSegmentCollection timebaseSegments = sequenceData.generateVariableTimebaseSegments(timebaseType, Common.getPeriodFromFrequency(masterFrequency)); bool[] variableTimebaseBuffer = sequenceData.getVariableTimebaseClock(timebaseSegments); if (deviceName.ToUpper() != HardwareChannel.parseDeviceNameStringFromPhysicalChannelString(channelName).ToUpper()) { throw new Exception("The variable timebase device " + HardwareChannel.parseDeviceNameStringFromPhysicalChannelString(channelName) + " does not match device " + deviceName + ". These must match for their their task to be created together."); } int timebasePortNum; int timebaseLineNum; try { timebasePortNum = HardwareChannel.parsePortNumberFromChannelString(channelName); timebaseLineNum = HardwareChannel.parseLineNumberFromChannelString(channelName); } catch (Exception) { throw new Exception("Channel name " + channelName + " is not a valid digital channel name. Cannot create a variable timebase output on this channel."); } if (portsToUse == null) { portsToUse = new List <int>(); portsToUse.Add(timebasePortNum); int spousePort; // this port is likely to have a shared sample clock with timebasePortNum, // at least in my experience so far. if (timebasePortNum % 2 == 0) { spousePort = timebasePortNum + 1; } else { spousePort = timebasePortNum - 1; } portsToUse.Add(spousePort); } if (!portsToUse.Contains(timebasePortNum)) { portsToUse.Add(timebasePortNum); } bool otherChannelsUsedOnUsedPort = false; foreach (HardwareChannel hc in usedDigitalChannels.Values) { if (hc.DeviceName.ToUpper() == deviceName.ToUpper()) { if (portsToUse.Contains(hc.daqMxDigitalPortNumber())) { otherChannelsUsedOnUsedPort = true; } } } if (otherChannelsUsedOnUsedPort) { throw new Exception("Variable timebase channel is on a port that shares a sample clock with a used output channel (on most devices, port 0 and 1 have a shared clock, and port 2 and 3 have a shared clock). This usage is not recommended, and not currently supported. Aborting buffer generation."); #region Deprecated code /* * Task task = new Task("Variable timebase output task"); * * // Create channels in the task * foreach (int portNum in portsToUse) * { * task.DOChannels.CreateChannel(deviceName + '/' + HardwareChannel.digitalPhysicalChannelName(portNum), "", ChannelLineGrouping.OneChannelForAllLines); * } * * // Configure the task... * * task.Timing.ConfigureSampleClock("", masterFrequency, SampleClockActiveEdge.Rising, SampleQuantityMode.FiniteSamples, variableTimebaseBuffer.Length); * * if (serverSettings.VariableTimebaseTriggerInput != "") * { * task.Triggers.StartTrigger.ConfigureDigitalEdgeTrigger(serverSettings.VariableTimebaseTriggerInput, DigitalEdgeStartTriggerEdge.Rising); * } * * * // Figure out which ports we are going to use, and which digital ID each line on each of those ports * // maps to. * Dictionary<int, HardwareChannel> digitalChannelsToUse = getChannelsOnDevice(usedDigitalChannels, deviceName); * List<int> temp = new List<int>(digitalChannelsToUse.Keys); * foreach (int id in temp) * { * HardwareChannel ch = digitalChannelsToUse[id]; * if (!portsToUse.Contains(HardwareChannel.parsePortNumberFromChannelString(ch.ChannelName))) * { * digitalChannelsToUse.Remove(id); * } * } * * // Remove all of the digital channels this buffer generation is consuming from the * // usedDigitalChannels dictionary. Why? Because there may still be another task to * // generate on this device, and this is a way of keeping track of which channels * // have already had their buffers generated. * // Since digitalChannelsToUse gets passed by reference from AtticusServerRuntime.generateBuffers(...), * // these changes thus get communicated back to AtticusServerRuntime. * foreach (HardwareChannel hc in digitalChannelsToUse.Values) * { * foreach (int i in usedDigitalChannels.Keys) * { * if (usedDigitalChannels[i] == hc) * { * usedDigitalChannels.Remove(i); * break; * } * } * } * * List<int> ids = new List<int>(digitalChannelsToUse.Keys); * ids.Sort(); * List<HardwareChannel> hcs = new List<HardwareChannel>(); * foreach (int id in ids) * { * hcs.Add(digitalChannelsToUse[id]); * } * * Dictionary<int, int[]> port_digital_ids; * List<int> usedPorts; * * groupDigitalChannels(ids, hcs, out port_digital_ids, out usedPorts); * * * * // now to generate the buffers. * * * if (usedPorts.Count != 0) * { * byte[,] digitalBuffer; * * * try * { * digitalBuffer = new byte[usedPorts.Count, variableTimebaseBuffer.Length]; * } * catch (Exception e) * { * throw new Exception("Unable to allocate digital buffer for device " + deviceName + ". Reason: " + e.Message + "\n" + e.StackTrace); * } * * for (int i = 0; i < usedPorts.Count; i++) * { * int portNum = usedPorts[i]; * byte digitalBitMask = 1; * for (int lineNum = 0; lineNum < 8; lineNum++) * { * bool[] singleChannelBuffer = null; * * if (portNum == timebasePortNum && lineNum == timebaseLineNum) * { // this current line is the variable timebase... * singleChannelBuffer = variableTimebaseBuffer; * } * else * { * int digitalID = port_digital_ids[portNum][lineNum]; * if (digitalID != -1) * { * if (settings.logicalChannelManager.Digitals[digitalID].overridden) * { * singleChannelBuffer = new bool[variableTimebaseBuffer.Length]; * if (settings.logicalChannelManager.Digitals[digitalID].digitalOverrideValue) * { * for (int j = 0; j < singleChannelBuffer.Length; j++) * { * singleChannelBuffer[j] = true; * } * } * } * else * { * singleChannelBuffer = sequenceData.getDigitalBufferClockSharedWithVariableTimebaseClock(timebaseSegments, digitalID, 1.0 / deviceSettings.SampleClockRate); * } * } * } * * if (singleChannelBuffer != null) * { * for (int j = 0; j < singleChannelBuffer.Length; j++) * { * if (singleChannelBuffer[j]) * { * digitalBuffer[i, j] |= digitalBitMask; * } * } * } * digitalBitMask = (byte)(digitalBitMask << 1); * * } * } * System.GC.Collect(); * DigitalMultiChannelWriter writer = new DigitalMultiChannelWriter(task.Stream); * writer.WriteMultiSamplePort(false, digitalBuffer); * * * } * * * return task; */ #endregion } else { return(createDaqMxVariableTimebaseSource( channelName, masterFrequency, sequenceData, timebaseType, serverSettings, deviceSettings)); } }