/// <summary>
/// IDriver implementation: Init
/// </summary>
/// <param name="cmDDK">The DDK instance</param>
public void Init(IDDK cmDDK)
{
m_CmDDK = cmDDK;
XmlDocument doc = new XmlDocument();
doc.LoadXml(m_Configuration);
// create the master device
m_MasterDevice = new ChannelTestDevice();
IDevice master = m_MasterDevice.OnCreate(this, cmDDK, DeviceName(doc, "ChannelTest"));
// create the fixed rate channel
m_FixedRateChannel = new FixedRateChannel();
m_FixedRateChannel.OnCreate(cmDDK, master, DeviceName(doc, "FixedRateChannel"));
// create the timestamped channel (double, double)
m_TimestampedChannelDouble = new TimestampedChannelDouble();
m_TimestampedChannelDouble.OnCreate(cmDDK, master, DeviceName(doc, "TimestampedChannel"));
// create the timestamped channel (Int64, Int64)
m_TimestampedChannelInt64 = new TimestampedChannelInt64();
m_TimestampedChannelInt64.OnCreate(cmDDK, master, DeviceName(doc, "Int64Channel"));
// create the spectral channel
m_PDAChannel = new PDAChannel();
m_PDAChannel.OnCreate(cmDDK, master, DeviceName(doc, "PDAChannel"));
}
public DeviceProperties(IDDK ddk, IDevice device, string deviceId, string deviceType, string deviceName)
{
if (ddk == null)
{
throw new ArgumentNullException("ddk");
}
if (device == null)
{
throw new ArgumentNullException("device");
}
if (string.IsNullOrEmpty(deviceType))
{
throw new ArgumentNullException("deviceType");
}
if (string.IsNullOrEmpty(deviceName))
{
throw new ArgumentNullException("deviceName");
}
if (deviceName.Length != deviceName.Trim().Length)
{
throw new ArgumentException("Device Name is invalid - it starts or ends with space");
}
// ModelNo is used to identify the device in the instrument method editor plug-in
Debug.Assert(StandardPropertyID.ModelNo.ToString() == Property.ConstantName.ModelNo);
}
public void OnGenericXmlRequest(IDDK cmDDK, string inputString, out string outputString)
{
XmlDocument xmlDocIn = new XmlDocument();
xmlDocIn.LoadXml(inputString);
XmlNode customXmlNode = xmlDocIn.SelectSingleNode("//CustomXML");
if (customXmlNode == null)
{
outputString = "<Reply><Error>Unknown custom XML</Error></Reply>";
return;
}
if (customXmlNode.InnerText == "...") // for round trip testing
{
outputString = "<Reply><Success>" + inputString + "</Success></Reply>";
}
else
{
String response = m_Device.DoSomething(customXmlNode.InnerText);
XmlDocument xmlDocOut = new XmlDocument();
xmlDocOut.PreserveWhitespace = true;
XmlNode replyNode = xmlDocOut.CreateNode(XmlNodeType.Element, "Reply", "");
xmlDocOut.AppendChild(replyNode);
XmlNode successNode = xmlDocOut.CreateNode(XmlNodeType.Element, "Success", "");
successNode.InnerText = response;
replyNode.AppendChild(successNode);
outputString = xmlDocOut.OuterXml;
}
}
void IDriverSendReceive.OnSendReceive(IDDK ddk, string xmlTextRequest, out string xmlTextResponse)
{
if (ddk == null)
{
throw new ArgumentNullException("ddk");
}
xmlTextResponse = string.Empty;
xmlTextResponse = string.Empty;
try
{
}
catch (Exception ex)
{
//Log.TaskEnd(Id, ex);
//CommandResponse commandResponse = new CommandResponse(commandId, ex);
//xmlTextResponse = commandResponse.XmlText;
//// In general ddk.AuditMessage is not need here. Let the UI display the error from the xmlTextResponse.
//bool showErrorAsAuditTrail = false;
//if (showErrorAsAuditTrail)
//{
// ddk.AuditMessage(AuditLevel.Error, ex.Message);
//}
}
}
/// Create our Dionex.Chromeleon.Symbols.IDevice and our Properties and Commands
internal IDevice Create(IDDK cmDDK, string name)
{
// Create our Dionex.Chromeleon.Symbols.IDevice
m_MyCmDevice = cmDDK.CreateDevice(name, "This is a preflight test device.");
// create the standard Property containing our model number
m_ModelNoProperty =
m_MyCmDevice.CreateStandardProperty(StandardPropertyID.ModelNo, cmDDK.CreateString(20));
m_someProperty = m_MyCmDevice.CreateBooleanProperty("Test", "Use this property to watch all preflight events.", "Off", "On");
m_someProperty.OnPreflightSetProperty += new SetPropertyEventHandler(OnPfTest);
m_someProperty.OnSetProperty += new SetPropertyEventHandler(OnTest);
m_MyCmDevice.OnPreflightBegin += new PreflightEventHandler(OnPfBegin);
m_MyCmDevice.OnPreflightEnd += new PreflightEventHandler(OnPfEnd);
m_MyCmDevice.OnPreflightLatch += new PreflightEventHandler(OnPfLatch);
m_MyCmDevice.OnPreflightSync += new PreflightEventHandler(OnPfSync);
m_MyCmDevice.OnPreflightBroadcast += new BroadcastEventHandler(OnPfBroadcast);
m_MyCmDevice.OnTransferPreflightToRun += new PreflightEventHandler(OnTransferPfToRun);
ICommand command =
m_MyCmDevice.CreateCommand("DoAbort", "This command sends an abort error.");
command.OnCommand += new CommandEventHandler(OnDoAbort);
command =
m_MyCmDevice.CreateCommand("DoError", "This command sends an error.");
command.OnCommand += new CommandEventHandler(OnDoError);
return(m_MyCmDevice);
}
public static ITypeDouble CreatePercentType(IDDK ddk, double min, double max, int digits)
{
ITypeDouble result = ddk.CreateDouble(min, max, digits);
result.Unit = UnitConversionEx.PhysUnitName(UnitConversion.PhysUnitEnum.PhysUnit_Percent);
return(result);
}
public PumpProperties(IDDK ddk, IDevice device)
{
if (ddk == null)
{
throw new ArgumentNullException("ddk");
}
if (device == null)
{
throw new ArgumentNullException("device");
}
Ready = Property.CreateReady(ddk, device);
// Pressure.LowerLimit
// Pressure.UpperLimit
// Pressure.Value
m_Pressure = device.CreateStruct("Pressure", "The pump pressure.");
ITypeDouble pressureType = ddk.CreateDouble(0, 400, 3);
pressureType.Unit = UnitConversionEx.PhysUnitName(UnitConversion.PhysUnitEnum.PhysUnit_Bar);
PressureValue = m_Pressure.CreateStandardProperty(StandardPropertyID.Value, pressureType);
PressureValue.Update(0);
PressureLowerLimit = m_Pressure.CreateStandardProperty(StandardPropertyID.LowerLimit, pressureType);
PressureLowerLimit.Update(pressureType.Minimum);
PressureUpperLimit = m_Pressure.CreateStandardProperty(StandardPropertyID.UpperLimit, pressureType);
PressureUpperLimit.Update(pressureType.Maximum);
m_Pressure.DefaultGetProperty = PressureValue;
}
public static IIntProperty CreateInt(IDDK ddk, IStruct structure, string name, string helpText = null)
{
ITypeInt typeInt = CreateIntType(ddk);
IIntProperty result = structure.CreateProperty(name, helpText, typeInt);
return(result);
}
public Heater(IDriverEx driver, IDDK ddk, Config.Heater config, string id)
: base(driver, ddk, config, typeof(Heater).Name, id)
{
Log.TaskBegin(Id);
try
{
m_Properties = new HeaterProperties(m_DDK, config, m_Device);
// Enable the scenario below:
// Heater.TemperatureNominal N
// Wait Heater.Ready
m_Properties.TemperatureNominal.ImmediateNotReady = true;
m_Properties.TemperatureControl.OnSetProperty += OnPropertyTemperatureControlSet;
m_Properties.TemperatureNominal.OnPreflightSetProperty += OnPropertyTemperatureNominalSetPreflight;
m_Properties.TemperatureNominal.OnSetProperty += OnPropertyTemperatureNominalSet;
m_Device.OnPreflightSync += OnDevicePreflightSync;
Log.TaskEnd(Id);
}
catch (Exception ex)
{
Log.TaskEnd(Id, ex);
throw;
}
}
public ChannelProperties(IDDK ddk, IChannel channel)
{
if (ddk == null)
{
throw new ArgumentNullException("ddk");
}
if (channel == null)
{
throw new ArgumentNullException("channel");
}
ITypeDouble typeDouble = Property.CreateDoubleType(ddk, UnitConversion.PhysUnitEnum.PhysUnit_Hertz, 0.1, 1000, 1);
Rate = channel.CreateProperty("Rate", "The data collection rate in " + typeDouble.Unit, typeDouble);
Rate.Update(100);
typeDouble = Property.CreateDoubleType(ddk, UnitConversion.PhysUnitEnum.PhysUnit_NanoMeter, 200, 400, 1);
Wavelength = channel.CreateStandardProperty(StandardPropertyID.Wavelength, typeDouble);
AcquisitionTimeOn = Property.CreateString(ddk, channel, "AcquisitionTime_1_On");
AcquisitionTimeOff = Property.CreateString(ddk, channel, "AcquisitionTime_2_Off");
AcquisitionTimeDiff = Property.CreateString(ddk, channel, "AcquisitionTime_3_Diff");
// Make the property available as a report variable. This is stored with the signal as meta data.
channel.AddPropertyToChannelInfo(Rate);
channel.AddPropertyToChannelInfo(Wavelength);
}
public DetectorChannelProperties(IDDK ddk, IDevice device, int deviceNumber, IChannel channel)
: base(ddk, channel)
{
if (ddk == null)
{
throw new ArgumentNullException("ddk");
}
if (device == null)
{
throw new ArgumentNullException("device");
}
if (deviceNumber <= 0)
{
throw new ArgumentException("Parameter deviceNumber = " + deviceNumber.ToString() + " must be > 0");
}
DetectorChannel.Location location = (DetectorChannel.Location)deviceNumber;
#if DEBUG
string locationName = Enum.GetName(typeof(DetectorChannel.Location), deviceNumber);
if (string.IsNullOrEmpty(locationName))
{
Device.DebuggerBreak();
}
#endif
Location = Property.CreateEnum(ddk, device, Property.ConstantName.Location, location);
// Location can also be just a number
//Location = Property.CreateInt(ddk, device, Property.ConstantName.Location";
//Location.Update(deviceNumber);
}
/// <summary>
/// Create our Dionex.Chromeleon.Symbols.IDevice and our Properties and Commands
/// </summary>
/// <param name="cmDDK">The DDK instance</param>
/// <param name="name">The name for our device</param>
/// <returns>our IDevice object</returns>
internal IDevice Create(IDDK cmDDK, string name)
{
// Create our Dionex.Chromeleon.Symbols.IDevice
m_MyCmDevice = cmDDK.CreateDevice(name, "This is device that illustrates the usage of IDevice.DelayTermination.");
m_DelayTerminationProperty =
m_MyCmDevice.CreateBooleanProperty("DelayTermination", "Enable/Disable termination delay.", "Off", "On");
m_DelayTerminationProperty.OnSetProperty += new SetPropertyEventHandler(m_DelayTerminationProperty_OnSetProperty);
ITypeInt tTimeout = cmDDK.CreateInt(0, 30);
tTimeout.Unit = "s";
m_TerminationTimeoutProperty =
m_MyCmDevice.CreateProperty("TerminationTimeout", "The timeout for the delayed termination.", tTimeout);
m_TerminationTimeoutProperty.OnSetProperty += new SetPropertyEventHandler(m_TerminationTimeoutProperty_OnSetProperty);
m_TerminateInTimeProperty =
m_MyCmDevice.CreateBooleanProperty("TerminateInTime", "Enable/Disable proper termination.", "Off", "On");
m_TerminateInTimeProperty.OnSetProperty += new SetPropertyEventHandler(m_TerminateInTimeProperty_OnSetProperty);
m_MyCmDevice.OnTransferPreflightToRun += new PreflightEventHandler(m_MyCmDevice_OnTransferPreflightToRun);
m_MyCmDevice.OnBroadcast += new BroadcastEventHandler(m_MyCmDevice_OnBroadcast);
m_ProgramTimer.Elapsed += new System.Timers.ElapsedEventHandler(m_ProgramTimer_Elapsed);
return(m_MyCmDevice);
}
public Device(IDDK cmDDK)
{
m_DDK = cmDDK;
m_Device = m_DDK.CreateDevice("MyDevice", "Device that dumps all events to the audit trail");
IIntProperty simpleProperty = m_Device.CreateBooleanProperty("SimpleProperty", "help text", "False", "True");
simpleProperty.OnPreflightSetProperty += new SetPropertyEventHandler(simpleProperty_OnPreflightSetProperty);
simpleProperty.OnSetProperty += new SetPropertyEventHandler(simpleProperty_OnSetProperty);
m_Device.OnBroadcast += new BroadcastEventHandler(m_Device_OnBroadcast);
// will be called 100 times a second ... m_Device.OnLatch += new RuntimeEventHandler(m_Device_OnLatch);
// will be called 100 times a second ... m_Device.OnSync += new RuntimeEventHandler(m_Device_OnSync);
m_Device.OnPreflightBegin += new PreflightEventHandler(m_Device_OnPreflightBegin);
m_Device.OnPreflightBroadcast += new BroadcastEventHandler(m_Device_OnPreflightBroadcast);
m_Device.OnPreflightLatch += new PreflightEventHandler(m_Device_OnPreflightLatch);
m_Device.OnPreflightSync += new PreflightEventHandler(m_Device_OnPreflightSync);
m_Device.OnPreflightEnd += new PreflightEventHandler(m_Device_OnPreflightEnd);
m_Device.OnTransferPreflightToRun += new PreflightEventHandler(m_Device_OnTransferPreflightToRun);
m_Device.OnBatchPreflightBegin += new BatchPreflightEventHandler(m_Device_OnBatchPreflightBegin);
m_Device.OnBatchPreflightSample += new SamplePreflightEventHandler(m_Device_OnBatchPreflightSample);
m_Device.OnBatchPreflightStandAloneProgram += new BatchEntryPreflightEventHandler(m_Device_OnBatchPreflightStandAloneProgram);
m_Device.OnBatchPreflightEmergencyProgram += new BatchEntryPreflightEventHandler(m_Device_OnBatchPreflightEmergencyProgram);
m_Device.OnBatchPreflightEnd += new BatchPreflightEventHandler(m_Device_OnBatchPreflightEnd);
m_Device.OnSequenceStart += new SequencePreflightEventHandler(m_Device_OnSequenceStart);
m_Device.OnSequenceEnd += new SequencePreflightEventHandler(m_Device_OnSequenceEnd);
m_Device.OnSequenceChange += new SequenceChangeEventHandler(m_Device_OnSequenceChange);
}
internal IDevice Create(IDDK cmDDK, string name)
{
// Create our IDevice object
m_MyCmDevice = cmDDK.CreateDevice(name, "Nelson NCI 900 Master Device");
// Create our properties
// ModelNo
m_ModelNoProperty =
m_MyCmDevice.CreateStandardProperty(StandardPropertyID.ModelNo, cmDDK.CreateString(20));
// DebugCommand
ITypeString tString = cmDDK.CreateString(255);
m_DebugCommand = m_MyCmDevice.CreateProperty("DebugCommand",
"For internal use only.", tString);
m_DebugCommand.AuditLevel = AuditLevel.Message;
m_DebugCommand.OnSetProperty += new SetPropertyEventHandler(OnDebugCommand);
ITypeDouble tDouble = cmDDK.CreateDouble(0, 100, 1);
tDouble.Unit = "%";
IProperty dblProp =
m_MyCmDevice.CreateProperty("DoubleProp", "DoubleHelp", tDouble);
return(m_MyCmDevice);
}
public Demo(IDriverEx driver, IDDK ddk, Config.Demo config, string id, InstrumentDataList instrumentDataList, string driverFolder)
: base(driver, ddk, config, typeof(Demo).Name, id)
{
Log.TaskBegin(Id);
try
{
if (string.IsNullOrEmpty(driverFolder))
{
throw new ArgumentNullException("driverFolder");
}
if (instrumentDataList == null)
{
throw new ArgumentNullException("instrumentDataList");
}
m_Properties = new DemoProperties(driver, m_DDK, config, m_Device);
//-------------------------------------------------------------------------------------------------------------------
if (m_DDK.InstrumentMap == null)
{
throw new InvalidOperationException("DDK.InstrumentMap is Null");
}
long instrumentsMap = m_DDK.InstrumentMap.Value;
if (instrumentsMap == (long)InstrumentID.None)
{
throw new InvalidOperationException("DDK.InstrumentMap = " + instrumentsMap.ToString() + " must be != " + ((long)InstrumentID.None).ToString());
}
string instrumentsMapBinary = InstrumentData.GetBitMapBinary(instrumentsMap);
string instrumentsNames = instrumentDataList.GetNames();
bool logInFile = LogInFile;
string fileNamePrefix = instrumentDataList[0].Name;
Log.Init(Id, logInFile, fileNamePrefix);
// Logging in a file starts here, if logInFile is True
const string indent = "\t";
string text = Environment.NewLine + Environment.NewLine +
indent + "Driver Folder \"" + driverFolder + "\"" + Environment.NewLine +
indent + "Name \"" + Name + "\", IsSimulated = " + IsSimulated.ToString() + Environment.NewLine +
indent + "USB Address \"" + UsbAddress + "\"" + Environment.NewLine +
indent + "DDK.InstrumentMap = " + instrumentsMap.ToString() + " = " + instrumentsMapBinary + " = " + instrumentsNames +
Environment.NewLine;
Log.WriteLine(Id, text);
//-------------------------------------------------------------------------------------------------------------------
m_Properties.LogInFile.OnSetProperty += OnPropertyLogInFileSet;
//-------------------------------------------------------------------------------------------------------------------
CommandTestInit();
CommandStartStopInit();
Log.TaskEnd(Id);
}
catch (Exception ex)
{
Log.TaskEnd(Id, ex);
throw;
}
}
public DetectorChannel(IDriverEx driver, IDDK ddk, IDevice owner, string id, string channelName, int channelNumber, UnitConversion.PhysUnitEnum unit, bool channelNeedsIntegration, string channelPhysicalQuantity)
: base(driver, ddk, typeof(DetectorChannel).Name, id, channelName, owner, CreateChannel(ddk, channelName, unit))
{
m_Number = channelNumber;
Log.TaskBegin(Id);
try
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
m_Channel = m_Device as IChannel;
if (m_Channel == null)
{
if (m_Device == null)
{
throw new InvalidOperationException("The device is not created");
}
if (m_Channel == null)
{
throw new InvalidOperationException("The device is type " + m_Device.GetType().FullName + " is not " + typeof(IChannel).FullName);
}
}
m_Properties = new DetectorChannelProperties(m_DDK, m_Device, channelNumber, m_Channel);
m_Channel.PhysicalQuantity = channelPhysicalQuantity; // What do we actually measure
m_Channel.NeedsIntegration = channelNeedsIntegration; // If False then this channel doesn't have peaks and, we don't want to have it integrated
Rate = 100;
// Signal scaling
m_Channel.SignalFactorProperty.Update(1);
m_Properties.Wavelength.OnSetProperty += OnPropertyWaveLengthSet;
m_Channel.AcquisitionOnCommand.OnPreflightCommand += OnCommandAcquisitionOnPreflight;
m_Channel.AcquisitionOnCommand.OnCommand += OnCommandAcquisitionOn;
m_Channel.AcquisitionOffCommand.OnPreflightCommand += OnCommandAcquisitionOffPreflight;
m_Channel.AcquisitionOffCommand.OnCommand += OnCommandAcquisitionOff;
m_Channel.OnDataFinished += OnChannelDataFinished;
m_Driver.OnConnected += OnDriverConnected;
m_Driver.OnDisconnected += OnDriverDisconnected;
m_Timer = new System.Timers.Timer(1000);
m_Timer.Elapsed += OnTimerElapsed;
Log.TaskEnd(Id);
}
catch (Exception ex)
{
Log.TaskEnd(Id, ex);
throw;
}
}
public static IIntProperty CreateReady(IDDK ddk, IDevice device)
{
ITypeInt type = CreateBoolType(ddk);
IIntProperty result = device.CreateStandardProperty(StandardPropertyID.Ready, type);
result.Update(GetBoolNumber(true));
return(result);
}
public static IIntProperty CreateEnum <T>(IDDK ddk, IStruct structure, string name, T value, string helpText = null)
{
ITypeInt typeInt = CreateEnumType <T>(ddk);
IIntProperty result = structure.CreateProperty(name, string.Empty, typeInt);
UpdateEnumProperty(result, value, helpText);
return(result);
}
public static IIntProperty CreateEnum <T>(IDDK ddk, IDevice device, string name, string helpText = null)
{
ITypeInt typeInt = CreateEnumType <T>(ddk);
IIntProperty result = device.CreateProperty(name, string.Empty, typeInt);
result.HelpText = helpText;
return(result);
}
/// <summary>
/// IDriver implementation: Init
/// </summary>
/// <param name="cmDDK">The DDK instance</param>
public void Init(IDDK cmDDK)
{
ConfigurationParser configurationParser =
new ConfigurationParser(m_Configuration);
m_Device = new BlobDataDevice();
m_Device.Create(cmDDK, configurationParser.GetDeviceName("Blob data device"));
}
public static IStringProperty CreateString(IDDK ddk, IStruct structure, string name, string helpText = null, int valueMaxLength = 300)
{
if (valueMaxLength <= 0)
{
throw new ArgumentOutOfRangeException("Parameter valueMaxLength must be > 0");
}
return(structure.CreateProperty(name, helpText, ddk.CreateString(valueMaxLength)));
}
/// <summary>Initializes the data with the specified instruments in the instrumentsMap parameter.</summary>
public void Init(IDDK ddk, long instrumentsMap)
{
if (ddk == null)
{
throw new ArgumentNullException("ddk");
}
Init(ddk.GetInstrumentName, instrumentsMap);
}
/// <summary>
/// Create our Dionex.Chromeleon.Symbols.IDevice and our Properties and Commands
/// </summary>
/// <param name="cmDDK">The DDK instance</param>
/// <param name="name">The name for our device</param>
/// <returns>our IDevice object</returns>
internal IDevice Create(IDDK cmDDK, string name)
{
m_MyCmDDK = cmDDK;
// Create our Dionex.Chromeleon.Symbols.IDevice
m_MyCmDevice = cmDDK.CreateDevice(name, "Autosampler device.");
ITypeDouble tVolume = cmDDK.CreateDouble(0.1, 10.0, 1);
tVolume.Unit = "µL";
ITypeInt tPosition = cmDDK.CreateInt(1, 10);
for (int i = 1; i <= 10; i++)
{
tPosition.AddNamedValue("RA" + i.ToString(), i);
}
tPosition.NamedValuesOnly = false;
m_InjectHandler = m_MyCmDevice.CreateInjectHandler(tVolume, tPosition);
m_InjectHandler.PositionProperty.OnSetProperty +=
new SetPropertyEventHandler(OnSetPosition);
m_InjectHandler.VolumeProperty.OnSetProperty +=
new SetPropertyEventHandler(OnSetVolume);
m_InjectHandler.InjectCommand.OnCommand += new CommandEventHandler(OnInject);
ICommand simulateVialNotFoundCommand =
m_MyCmDevice.CreateCommand("SimulateVialNotFound", "Simulate a vial not found error");
simulateVialNotFoundCommand.OnCommand += new CommandEventHandler(simulateVialNotFoundCommand_OnCommand);
ICommand modifyPositionTypeCommand =
m_MyCmDevice.CreateCommand("ModifyPositionType", "Changes the data type of the Position property and the Inject.Position parameter");
modifyPositionTypeCommand.OnCommand += new CommandEventHandler(modifyPositionTypeCommand_OnCommand);
ICommand modifyVolumeTypeCommand =
m_MyCmDevice.CreateCommand("ModifyVolumeType", "Changes the data type of the Volume property and the Inject.Volume parameter");
modifyVolumeTypeCommand.OnCommand += new CommandEventHandler(modifyVolumeTypeCommand_OnCommand);
ITypeString tTrayDescription = cmDDK.CreateString(500); // ensure length is sufficient, but don't be too generous
m_TrayDesciptionProperty = m_MyCmDevice.CreateStandardProperty(StandardPropertyID.TrayDescription, tTrayDescription);
m_TrayDesciptionProperty.AuditLevel = AuditLevel.Service;
m_TrayDesciptionProperty.Update(GenerateTrayDescription());
// In this example driver, simulating the injection process
// is handled by a timer started by the Inject command.
// When the timer has elapsed the inject response is generated.
m_InjectionTimer.Elapsed += new System.Timers.ElapsedEventHandler(m_InjectionTimer_Elapsed);
m_InjectionTimer.AutoReset = false;
return(m_MyCmDevice);
}
/// <summary>
/// IDriver implementation: Init
/// IDriver.Init is called after successful configuration of the driver.
/// During IDriver.Init a driver must create its devices, properties, etc.
/// </summary>
/// <param name="cmDDK">The DDK instance that hosts the driver.</param>
public void Init(IDDK cmDDK)
{
ConfigurationParser configurationParser =
new ConfigurationParser(m_Configuration);
// Create our device.
m_AutoSamplerDevice = new AutoSamplerDevice();
m_AutoSamplerDevice.Create(cmDDK, configurationParser.GetDeviceName("Sampler"));
}
private static IDevice CreateChannel(IDDK ddk, string name, UnitConversion.PhysUnitEnum unit)
{
ITypeInt typeSignal = ddk.CreateInt(0, 1000);
typeSignal.Unit = UnitConversionEx.PhysUnitName(unit);
IChannel result = ddk.CreateChannel(name, "Detector channel", typeSignal);
return(result);
}
/// <summary>
/// This method is called to exchange data (string) with the driver. The main purpose
/// is to communicate with the driver configuration module.
/// </summary>
/// <remarks>
/// Note that OnSendReceive can be called BEFORE Init, therefore we receive the calling
/// IDDK instance as a parameter. When a driver is initially added to the instrument,
/// it is loaded but it will not be initialized until the user has confirmed the
/// configuration.
/// </remarks>
/// <param name="cmDDK">The DDK instance</param>
/// <param name="inputString">The string which is sent to the driver</param>
/// <param name="outputString">The answer string from the driver</param>
public void OnSendReceive(IDDK cmDDK, string inputString, out string outputString)
{
// Write the input to the audit trail.
cmDDK.AuditMessage(AuditLevel.Message, "OnSendReceive: inputString = " + inputString);
// Fill in some response.
outputString = DateTime.Now.ToString() + " - " + inputString;
cmDDK.AuditMessage(AuditLevel.Message, "OnSendReceive: outputString = " + outputString);
}
public static IDoubleProperty CreateDouble(IDDK ddk, IStruct structure, string name,
Nullable <UnitConversion.PhysUnitEnum> unit = null, string helpText = null,
double minValue = double.MinValue, double maxValue = double.MaxValue, int precision = 3)
{
ITypeDouble typeDouble = CreateDoubleType(ddk, unit, minValue, maxValue, precision);
IDoubleProperty result = structure.CreateProperty(name, helpText, typeDouble);
return(result);
}
/// <summary>
/// IDriver implementation: Init
/// </summary>
/// <param name="cmDDK">The DDK instance</param>
public void Init(IDDK cmDDK)
{
m_MyDevice = new LocalizedDevice();
ConfigurationParser configurationParser =
new ConfigurationParser(m_Configuration);
m_MyDevice.Create(cmDDK, configurationParser.GetDeviceName("Localized Device"));
}
internal void Create(IDDK cmDDK, string deviceName)
{
m_DDK = cmDDK;
m_Device = m_DDK.CreateDevice(deviceName, "Pump device");
IStringProperty typeProperty =
m_Device.CreateProperty("DeviceType",
"The DeviceType property tells us which component we are talking to.",
m_DDK.CreateString(20));
typeProperty.Update("Pump");
// A data type for our pump flow
ITypeDouble tFlow = m_DDK.CreateDouble(0, 10, 1);
tFlow.Unit = "ml/min";
// Create our flow handler. The flow handler creates a Flow.Nominal,
// a Flow.Value and 4 eluent component properties for us.
m_FlowHandler = m_Device.CreateFlowHandler(tFlow, 4, 2);
m_FlowHandler.FlowNominalProperty.OnSetProperty += OnSetFlow;
// initialize the flow
m_FlowHandler.FlowNominalProperty.Update(0);
// initialize the components
m_FlowHandler.ComponentProperties[0].Update(100.0);
m_FlowHandler.ComponentProperties[1].Update(0);
m_FlowHandler.ComponentProperties[2].Update(0);
m_FlowHandler.ComponentProperties[3].Update(0);
// A type for our pump pressure
ITypeDouble tPressure = m_DDK.CreateDouble(0, 400, 1);
tPressure.Unit = "bar";
// We create a struct for the pressure with Value, LowerLimit and UpperLimit
m_PressureStruct = m_Device.CreateStruct("Pressure", "The pump pressure.");
m_PressureValue = m_PressureStruct.CreateStandardProperty(StandardPropertyID.Value, tPressure);
m_PressureLowerLimit = m_PressureStruct.CreateStandardProperty(StandardPropertyID.LowerLimit, tPressure);
m_PressureLowerLimit.OnSetProperty += new SetPropertyEventHandler(OnSetPressureLowerLimit);
m_PressureLowerLimit.Update(0.0);
m_PressureUpperLimit = m_PressureStruct.CreateStandardProperty(StandardPropertyID.UpperLimit, tPressure);
m_PressureUpperLimit.OnSetProperty += new SetPropertyEventHandler(OnSetPressureUpperLimit);
m_PressureUpperLimit.Update(400.0);
m_PressureStruct.DefaultGetProperty = m_PressureValue;
m_Device.OnTransferPreflightToRun += new PreflightEventHandler(OnTransferPreflightToRun);
}
public static ITypeInt CreateBoolType(IDDK ddk)
{
int numberFalse = GetBoolNumber(false);
int numberTrue = GetBoolNumber(true);
ITypeInt result = CreateIntType(ddk, numberFalse, numberTrue);
result.AddNamedValue(false.ToString(), numberFalse);
result.AddNamedValue(true.ToString(), numberTrue);
return(result);
}
