private void CheckTemperature(double value) { ITypeDouble type = m_Properties.TemperatureValue.ValueType as ITypeDouble; Debug.Assert(type != null); string units = type != null ? " " + type.Unit : string.Empty; double valueMin = TemperatureMin; double valueMax = TemperatureMax; if (value < valueMin || value > valueMax) { throw new InvalidOperationException("Cannot set TemperatureValue = " + value.ToString() + units + ". Must be in [" + valueMin + ", " + valueMax.ToString() + "]"); } if (type != null) { valueMin = type.Minimum.GetValueOrDefault(); valueMax = type.Maximum.GetValueOrDefault(); if (value < valueMin || value > valueMax) { throw new InvalidOperationException("Cannot set TemperatureValue = " + value.ToString() + units + ". Must be in [" + valueMin + ", " + valueMax.ToString() + "]"); } } }
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 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); }
private void CheckTemperature(SetPropertyEventArgs args, double value) { if (args.RunContext.IsManual) // If this is requested manually by the user { if (!args.RunContext.IsSemanticCheck) // This is not just a check - the command will be executed after the preflight is successful { m_Driver.CheckIsCommunicating(); CheckIsTemperatureControlOn(); } } ITypeDouble type = m_Properties.TemperatureNominal.DataType; if (args.RunContext.IsManual) { // This check can be made only in manual mode, because the script can have steps that modify // TemperatureMin and/or TemperatureMax and therefor the current Min/Max values are not the ones the script sets if (value < TemperatureMin || value > TemperatureMax) { throw new InvalidOperationException("Cannot set TemperatureValue = " + value.ToString() + " " + type.Unit + ". Must be in [" + TemperatureMin + ", " + TemperatureMax.ToString() + "]"); } } double valueMin = type.Minimum.GetValueOrDefault(); double valueMax = type.Maximum.GetValueOrDefault(); if (value < valueMin || value > valueMax) { throw new InvalidOperationException("Cannot set TemperatureValue = " + value.ToString() + " " + type.Unit + ". Must be in [" + valueMin + ", " + valueMax.ToString() + "]"); } }
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 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; }
/// <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); }
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); }
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 ITypeDouble CreateDoubleType(IDDK ddk, Nullable <UnitConversion.PhysUnitEnum> unit = null, double minValue = double.MinValue, double maxValue = double.MaxValue, int precision = 3) { ITypeDouble result = ddk.CreateDouble(minValue, maxValue, precision); if (unit != null) { result.Unit = UnitConversionEx.PhysUnitName(unit.GetValueOrDefault()); } return(result); }
/// Create our Chromeleon symbols internal IChannel OnCreate(IDDK cmDDK, IDevice master, string name) { // Create a data type for our signal ITypeDouble tSignal = cmDDK.CreateDouble(-100.0, 100.0, 1); tSignal.Unit = "mV"; // Create the channel symbol m_MyCmDevice = cmDDK.CreateChannel(name, "Channel that can generate both sinus curve and sawtooth signal as Int64 data points.", tSignal); // We will be a subdevice of the master device m_MyCmDevice.SetOwner(master); // Attach our handlers to the AcquisitionOffCommand and AcquisitionOnCommand of the channel m_MyCmDevice.AcquisitionOffCommand.OnCommand += new CommandEventHandler(OnAcqOff); m_MyCmDevice.AcquisitionOnCommand.OnCommand += new CommandEventHandler(OnAcqOn); m_MyCmDevice.OnDataFinished += new DataFinishedEventHandler(m_MyCmDevice_OnDataFinished); // These two parameters are not longer relevant when using the new UpdateDataEx function // in contradiction to the old UpdateData interface. So leave these parameters unchanged; // the DDK will initialize them appropriately. m_MyCmDevice.TimeStepFactorProperty.Writeable = false; m_MyCmDevice.TimeStepDivisorProperty.Writeable = false; ITypeDouble tRateType = cmDDK.CreateDouble(0.1, 1000.0, 1); tRateType.Unit = "Hz"; m_RateProperty = m_MyCmDevice.CreateProperty("FixedRate", "The data collection rate in Hz.", tRateType); m_RateProperty.OnSetProperty += new SetPropertyEventHandler(m_RateProperty_OnSetProperty); ITypeInt tDataIndexType = cmDDK.CreateInt(0, int.MaxValue); m_DataIndexProperty = m_MyCmDevice.CreateProperty("TotalDataPoints", "Total number of data points.", tDataIndexType); ICommand noMoreDataCommand = m_MyCmDevice.CreateCommand("NoMoreData", "Send IChannel.NoMoreData to stop data acquisition immediately."); noMoreDataCommand.OnCommand += new CommandEventHandler(noMoreDataCommand_OnCommand); ITypeDouble tChannelTimeType = cmDDK.CreateDouble(0, 1000, 3); tChannelTimeType.Unit = "min"; m_ChannelTimeProperty = m_MyCmDevice.CreateProperty("ChannelTime", "Internal time of the channel.", tChannelTimeType); // This channel doesn't have peaks, we don't want to have it integrated. m_MyCmDevice.NeedsIntegration = false; return(m_MyCmDevice); }
void modifyPositionTypeCommand_OnCommand(CommandEventArgs args) { ITypeInt tNewPositionType = m_MyCmDDK.CreateInt(0, 20); for (int i = 0; i <= 20; i++) { tNewPositionType.AddNamedValue("X" + i.ToString(), i); } tNewPositionType.NamedValuesOnly = true; ITypeDouble tOldVolumeType = m_InjectHandler.VolumeProperty.DataType; // remains unchanged m_InjectHandler.UpdateDataTypes(tOldVolumeType, tNewPositionType); }
void modifyVolumeTypeCommand_OnCommand(CommandEventArgs args) { ITypeDouble tNewVolumeType = m_MyCmDDK.CreateDouble(0.00, 20.00, 2); tNewVolumeType.Unit = "mL"; double[] legalValues = new double[3]; legalValues[0] = 0.00; legalValues[1] = 10.00; legalValues[2] = 20.00; tNewVolumeType.LegalValues = legalValues; ITypeInt tOldPositionType = m_InjectHandler.PositionProperty.DataType; // remains unchanged m_InjectHandler.UpdateDataTypes(tNewVolumeType, tOldPositionType); }
/// <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, "PreparingSampler device."); ITypeDouble tVolume = cmDDK.CreateDouble(0.1, 10.0, 1); ITypeInt tPosition = cmDDK.CreateInt(1, 10); for (int i = 1; i < 10; i++) { tPosition.AddNamedValue("RA" + i.ToString(), i); } 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); m_PrepareNextSampleCommand = m_MyCmDevice.CreateCommand("PrepareNextSample", "Start sample preparation for the next injection."); m_PrepareNextSampleCommand.OnCommand += new CommandEventHandler(m_PrepareNextSampleCommand_OnCommand); // Note that before the batch preflight starts all contained methods are preflighted. m_MyCmDevice.OnPreflightBegin += new PreflightEventHandler(m_MyCmDevice_OnPreflightBegin); m_MyCmDevice.OnPreflightEnd += new PreflightEventHandler(m_MyCmDevice_OnPreflightEnd); m_MyCmDevice.OnTransferPreflightToRun += new PreflightEventHandler(m_MyCmDevice_OnTransferPreflightToRun); // The following events can be used to investigate injection properties and stand-alone methods // during batch preflight m_MyCmDevice.OnBatchPreflightBegin += new BatchPreflightEventHandler(m_MyCmDevice_OnBatchPreflightBegin); m_MyCmDevice.OnBatchPreflightSample += new SamplePreflightEventHandler(m_MyCmDevice_OnBatchPreflightSample); m_MyCmDevice.OnBatchPreflightStandAloneProgram += new BatchEntryPreflightEventHandler(m_MyCmDevice_OnBatchPreflightStandAloneProgram); m_MyCmDevice.OnBatchPreflightEmergencyProgram += new BatchEntryPreflightEventHandler(m_MyCmDevice_OnBatchPreflightEmergencyProgram); m_MyCmDevice.OnBatchPreflightEnd += new BatchPreflightEventHandler(m_MyCmDevice_OnBatchPreflightEnd); m_MyCmDevice.OnSequenceStart += new SequencePreflightEventHandler(m_MyCmDevice_OnSequenceStart); m_MyCmDevice.OnSequenceEnd += new SequencePreflightEventHandler(m_MyCmDevice_OnSequenceEnd); m_MyCmDevice.OnSequenceChange += new SequenceChangeEventHandler(m_MyCmDevice_OnSequenceChange); return(m_MyCmDevice); }
/// Create our Chromeleon symbols internal IChannel Create(IDDK cmDDK, string name) { // Create a data type for our signal ITypeInt tSignal = cmDDK.CreateInt(-100, 100); tSignal.Unit = "mV"; // Create the channel symbol m_MyCmDevice = cmDDK.CreateChannel(name, "This is a channel that can generate a sinus curve.", tSignal); // Attach our handlers to the AcquisitionOffCommand and AcquisitionOnCommand of the channel m_MyCmDevice.AcquisitionOffCommand.OnCommand += new CommandEventHandler(OnAcqOff); m_MyCmDevice.AcquisitionOnCommand.OnCommand += new CommandEventHandler(OnAcqOn); m_MyCmDevice.TimeStepFactorProperty.DataType.Minimum = 100; m_MyCmDevice.TimeStepFactorProperty.DataType.Maximum = 100; m_MyCmDevice.TimeStepFactorProperty.Writeable = false; m_MyCmDevice.TimeStepDivisorProperty.DataType.Minimum = 1; m_MyCmDevice.TimeStepDivisorProperty.DataType.Maximum = 100; m_MyCmDevice.TimeStepDivisorProperty.OnSetProperty += new SetPropertyEventHandler(OnTimeStepDivisor); ITypeDouble tWavelength = cmDDK.CreateDouble(200, 400, 1); tWavelength.Unit = "nm"; m_WavelengthProperty = m_MyCmDevice.CreateStandardProperty(StandardPropertyID.Wavelength, tWavelength); // We want to have the wavelength available as a report variable and therefore add it to the channel info. m_MyCmDevice.AddPropertyToChannelInfo(m_WavelengthProperty); // What do we actually measure? m_MyCmDevice.PhysicalQuantity = "MotorCurrent"; // This channel doesn't have peaks, we don't want to have it integrated. m_MyCmDevice.NeedsIntegration = false; // Create a command for writing a spectrum ICommand writeSpectrumCommand = m_MyCmDevice.CreateCommand("WriteSpectrum", "Write a spectrum"); writeSpectrumCommand.OnCommand += new CommandEventHandler(OnWriteSpectrum); // Create an interface for spectrum writing m_SpectrumWriter = m_MyCmDevice.CreateSpectrumWriter(); return(m_MyCmDevice); }
private static IDevice CreateChannel(IDDK ddk, string name, double min, double max, int digits, UnitConversion.PhysUnitEnum unit) { if (ddk == null) { throw new ArgumentNullException("ddk"); } if (string.IsNullOrEmpty(name)) { throw new ArgumentNullException("name"); } if (unit == UnitConversion.PhysUnitEnum.PhysUnit_Unknown) { throw new ArgumentException("The unit mus be specified"); } ITypeDouble typeSignal = ddk.CreateDouble(min, max, digits); typeSignal.Unit = UnitConversionEx.PhysUnitName(unit); IChannel result = ddk.CreateChannel(name, "Pump Pressure Channel", typeSignal); return(result); }
internal void Create(IDDK cmDDK, string deviceName) { m_DDK = cmDDK; m_Device = m_DDK.CreateDevice(deviceName, "Sampler device"); IStringProperty typeProperty = m_Device.CreateProperty("DeviceType", "The DeviceType property tells us which component we are talking to.", m_DDK.CreateString(20)); typeProperty.Update("Sampler"); ITypeDouble tVolume = m_DDK.CreateDouble(0.1, 10.0, 1); ITypeInt tPosition = m_DDK.CreateInt(1, 10); m_InjectHandler = m_Device.CreateInjectHandler(tVolume, tPosition); m_InjectHandler.PositionProperty.OnSetProperty += new SetPropertyEventHandler(OnSetPosition); m_InjectHandler.VolumeProperty.OnSetProperty += new SetPropertyEventHandler(OnSetVolume); m_InjectHandler.InjectCommand.OnCommand += new CommandEventHandler(OnInject); //Create ready property ITypeInt tReady = m_DDK.CreateInt(0, 1); //Add named values tReady.AddNamedValue("NotReady", 0); tReady.AddNamedValue("Ready", 1); m_ReadyProperty = m_Device.CreateStandardProperty(StandardPropertyID.Ready, tReady); m_ReadyProperty.Update(1); m_Device.OnBroadcast += new BroadcastEventHandler(OnBroadcast); }
internal void Create(IDDK cmDDK, string deviceName) { m_DDK = cmDDK; ITypeInt tSignal = m_DDK.CreateInt(0, 1000); tSignal.Unit = "mAU"; m_Channel = m_DDK.CreateChannel(deviceName, "Detector device", tSignal); IStringProperty typeProperty = m_Channel.CreateProperty("DeviceType", "The DeviceType property tells us which component we are talking to.", m_DDK.CreateString(20)); typeProperty.Update("Detector"); m_Channel.AcquisitionOffCommand.OnCommand += new CommandEventHandler(OnAcqOff); m_Channel.AcquisitionOnCommand.OnCommand += new CommandEventHandler(OnAcqOn); ITypeDouble tWavelength = m_DDK.CreateDouble(200, 400, 1); tWavelength.Unit = "nm"; m_WavelengthProperty = m_Channel.CreateStandardProperty(StandardPropertyID.Wavelength, tWavelength); m_WavelengthProperty.OnSetProperty += new SetPropertyEventHandler(OnSetWaveLength); // We want to have the wavelength available as a report variable and therefore add it to the channel info. m_Channel.AddPropertyToChannelInfo(m_WavelengthProperty); m_WavelengthProperty.Update(m_WaveLength); // What do we actually measure? m_Channel.PhysicalQuantity = "Absorbance"; m_Timer.Elapsed += new ElapsedEventHandler(OnTimedEvent); }
/// <summary> /// This illustrates variations on the ITypeDouble that can be used for creating properties /// </summary> internal void CreateMoreProperties(IDDK cmDDK) { ITypeDouble type1 = cmDDK.CreateDouble(-1, 1, 0); // Range: [-1...1] // - any number -1 <= x <= 1 can be assigned, will be rounded to 0 decimals // - user input is allowed with 0 decimals only (-1|0|1) // - numbers outside this range (-1|0|1) cause validation errors in panel edit controls or during Instrument Method syntax checking // - panel edit control's spin box will spin -1,0,1 // - F8 box's/Instrument Method Editor's drop list will contain -1,0,1 IDoubleProperty type1Property = m_MyCmDevice.CreateProperty("Type1Property", "", type1); type1Property.Update(-1); //set default value type1Property.OnSetProperty += new SetPropertyEventHandler(type1Property_OnSetProperty); ITypeDouble type2 = cmDDK.CreateDouble(-1, 1, 2); type2.Unit = "bar"; // Range: [-1.00..1.00 bar] // - any number -1 <= x <= 1 can be assigned, will be rounded to 2 decimals // - user input is allowed with up to 2 decimals // - numbers outside this range cause validation errors in panel edit controls or during Instrument Method syntax checking // - unit "bar" is shown in Commands overview (F8), // and can be appended to text shown in panel edit controls and panel string displays // - unit [bar] can be added to assignments in Instrument Method scripts, // system can also convert from other units if it makes sense, // e.g. Type2Property = 1 [psi] is equal to Type2Property = 0.0689475729 [bar] // - panel edit control's spin box will spin in 0.01 incrementals // - F8 box's/Instrument Method Editor's drop list will be empty as it would be too long (a maximum of 12 items can be shown) IDoubleProperty type2Property = m_MyCmDevice.CreateProperty("Type2Property", "", type2); type2Property.Update(0.0); //set default value type2Property.OnSetProperty += new SetPropertyEventHandler(type2Property_OnSetProperty); ITypeDouble type3 = cmDDK.CreateDouble(0, 20, 1); type3.AddNamedValue("Null", 0); type3.AddNamedValue("OnePointFive", 1.5); type3.AddNamedValue("Ten", 10); type3.AddNamedValue("Thirty", 30); // Range: [Null..20.0] - when a property is displayed or logged, a named value is used instead of a pure number if a named value is available. // - any number 0 <= x <= 20 can be assigned, will be rounded to 1 decimal // - 30 can also be assigned, even if it is outside the min/max range, because it has been added as named value // - user input is allowed with up to 1 decimal // - instead of Type3Property = 0, one can write Type3Property = Null // - instead of Type3Property = 1.5, one can write Type3Property = OnePointFive // - instead of Type3Property = 10, one can write Type3Property = Ten // - instead of Type3Property = 30, one can write Type3Property = Thirty // - panel edit control's spin box will spin in 0.1 incrementals: Null, 0.1, 0.2, ..., 1.4, OnePointFive, 1.6, .... 20.0, Thirty // - F8 box's/Instrument Method Editor's drop list contains the four named values IDoubleProperty type3Property = m_MyCmDevice.CreateProperty("Type3Property", "", type3); type3Property.Update(4);//set default value type3Property.OnSetProperty += new SetPropertyEventHandler(type3Property_OnSetProperty); ITypeDouble type4 = cmDDK.CreateDouble(0, 20, 1); type4.AddNamedValue("Null", 0); type4.AddNamedValue("Ten", 10); type4.AddNamedValue("Twenty", 20); type4.NamedValuesOnly = true; // Range: [Null..Twenty] - when a property is displayed or logged, a named value is used instead of a pure number if a named value is available. // - numbers 0.0, 10.0 and 20.0 can be assigned only, because of the 'NamedValuesOnly' flag. // - instead of Type3Property = 0, one can write Type3Property = Null // - instead of Type3Property = 10, one can write Type3Property = Ten // - instead of Type3Property = 20, one can write Type3Property = Twenty // - panel edit control's spin box will spin Null, Ten, Twenty only. Other values will cause validation errors // - F8 box's/Instrument Method Editor's drop list contains the three named values, other values will cause validation errors IDoubleProperty type4Property = m_MyCmDevice.CreateProperty("Type4Property", "", type4); type4Property.Update(0);//set default value type4Property.OnSetProperty += new SetPropertyEventHandler(type4Property_OnSetProperty); ITypeDouble type5 = cmDDK.CreateDouble(0, 20, 1); Double[] legalValues = { 1.1, 2.2, 3.3 }; type5.LegalValues = legalValues; // Range: [0.0..20.0] // - any (!) number 0 <= x <= 20 can be assigned, will be rounded to 1 decimal // - user input is allowed with up to 1 decimal // - panel edit control's spin box will spin to 1.1, 2.2 and 3.3 (due to LegalValues) // - F8 box's/Instrument Method Editor's drop list contains the three legal values IDoubleProperty type5Property = m_MyCmDevice.CreateProperty("Type5Property", "", type5); type5Property.Update(2.2);//set default value type5Property.OnSetProperty += new SetPropertyEventHandler(type5Property_OnSetProperty); ITypeDouble type6 = cmDDK.CreateDouble(0, 20, 1); type6.LegalValues = legalValues; type6.AddNamedValue("Null", 0); type6.AddNamedValue("OnePointFive", 1.5); type6.AddNamedValue("Ten", 10); type6.AddNamedValue("Twenty", 20); // Range: [Null..20.0] // - any (!) number 0 <= x <= 20 can be assigned, will be rounded to 1 decimal // - user input is allowed with up to 1 decimal // - panel edit control's spin box will spin to all legal and named values // - F8 box's/Instrument Method Editor's drop list contains the seven legal and named values IDoubleProperty type6Property = m_MyCmDevice.CreateProperty("Type6Property", "", type6); type6Property.Update(10);//set default value type6Property.OnSetProperty += new SetPropertyEventHandler(type6Property_OnSetProperty); ITypeInt badBooleanType = cmDDK.CreateInt(0, 1); IIntProperty badBoolean1 = m_MyCmDevice.CreateProperty("BadBoolean", "This is a Boolean type without enumerations. Please define appropriate enumerations in the driver!", badBooleanType); badBoolean1.OnSetProperty += new SetPropertyEventHandler(badBoolean_OnSetProperty); m_MyProperBoolean = m_MyCmDevice.CreateBooleanProperty("ProperBoolean", "This is how to do it", "False_No_Zero_NotReady", "True_Yes_One_Ready"); m_MyProperBoolean.OnSetProperty += new SetPropertyEventHandler(properBoolean_OnSetProperty); ITypeInt explicitBooleanType = cmDDK.CreateInt(0, 1); explicitBooleanType.AddNamedValue("False_No_Zero_NotReady", 0); explicitBooleanType.AddNamedValue("True_Yes_One_Ready", 1); explicitBooleanType.NamedValuesOnly = true; IIntProperty explicitBoolean = m_MyCmDevice.CreateProperty("ExplicitBoolean", "Also ok, but way more explicit code", explicitBooleanType); explicitBoolean.OnSetProperty += new SetPropertyEventHandler(explicitBoolean_OnSetProperty); }
public AutoSampler(IDriverEx driver, IDDK ddk, Config.AutoSampler config, string id) : base(driver, ddk, typeof(AutoSampler).Name, id, config.Name) { Log.TaskBegin(Id); try { m_Properties = new AutoSamplerProperties(m_DDK, m_Device); ITypeDouble volumeType = m_DDK.CreateDouble(0.1, 30, 3); volumeType.Unit = UnitConversionEx.PhysUnitName(UnitConversion.PhysUnitEnum.PhysUnit_MicroLiter); // µl int positionMax = m_RackInfos.Sum(item => item.TubeColumnsCount * item.TubeRowsCount); ITypeInt positionType = m_DDK.CreateInt(1, positionMax); positionType.NamedValuesOnly = false; int position = positionType.Minimum.GetValueOrDefault() - 1; foreach (RackInfo rack in m_RackInfos) { int tubeNumber = rack.TubeFirstNumber - 1; for (int row = 1; row <= rack.TubeRowsCount; row++) { for (int col = 1; col <= rack.TubeColumnsCount; col++) { position++; tubeNumber++; string positionName = rack.TubePositionNamePrefix + tubeNumber.ToString(); positionType.AddNamedValue(positionName, tubeNumber); } } } m_InjectHandler = m_Device.CreateInjectHandler(volumeType, positionType); m_RackDesciptionProperty = m_Device.CreateStandardProperty(StandardPropertyID.TrayDescription, m_DDK.CreateString(1000)); m_RackDesciptionProperty.AuditLevel = AuditLevel.Service; string rackDescription = GetRackDescription(); if (m_RackDesciptionProperty.DataType.Length < rackDescription.Length) { throw new InvalidOperationException("m_RackDesciptionProperty length " + m_RackDesciptionProperty.DataType.Length + " is less than the needed " + rackDescription.Length.ToString()); } m_RackDesciptionProperty.Update(rackDescription); m_Position = -1; m_VolumeUnitName = m_InjectHandler.VolumeProperty.DataType.Unit; // µl m_VolumeUnit = UnitConversionEx.PhysUnitFindName(m_VolumeUnitName); m_InjectHandler.PositionProperty.OnSetProperty += OnPropertyPositionSet; m_InjectHandler.VolumeProperty.OnSetProperty += OnPropertyVolumeSet; m_InjectHandler.InjectCommand.OnCommand += OnCommandInjectHandlerInject; m_Device.OnBatchPreflightBegin += OnDeviceBatchPreflightBegin; m_Device.OnPreflightEnd += OnDevicePreflightEnd; m_Device.OnTransferPreflightToRun += OnDeviceTransferPreflightToRun; m_Device.OnSequenceStart += OnDeviceSequenceStart; m_Device.OnSequenceChange += OnDeviceSequenceChange; m_Device.OnSequenceEnd += OnDeviceSequenceEnd; m_Device.OnBroadcast += OnDeviceBroadcast; m_Driver.OnConnected += OnDriverConnected; m_Driver.OnDisconnected += OnDriverDisconnected; Log.TaskEnd(Id); } catch (Exception ex) { Log.TaskEnd(Id, ex); throw; } }
public HeaterProperties(IDDK ddk, Config.Heater config, IDevice device) { if (ddk == null) { throw new ArgumentNullException("ddk"); } if (config == null) { throw new ArgumentNullException("config"); } if (device == null) { throw new ArgumentNullException("device"); } Ready = Property.CreateReady(ddk, device); m_Product = device.CreateStruct("Product", "Product Help Text"); m_ProductName = Property.CreateString(ddk, m_Product, "Name"); m_ProductName.Writeable = true; m_ProductName.Update("Product Name"); m_ProductDescription = Property.CreateString(ddk, m_Product, "Description"); m_ProductDescription.Update(config.ProductDescription); // Set the default read and write properties for the structure - optional m_Product.DefaultGetProperty = m_ProductName; m_Product.DefaultSetProperty = m_ProductName; Power = Property.CreateDouble(ddk, device, "Power", UnitConversion.PhysUnitEnum.PhysUnit_Watt, null, 0); // the unit W is localized // Temperature.Control - On/Off // Temperature.LowerLimit // Temperature.UpperLimit // Temperature.Nominal // Temperature.Value m_Temperature = device.CreateStruct("Temperature", "Heater Temperature"); TemperatureControl = Property.CreateEnum(ddk, m_Temperature, "Control", Heater.TemperatureControl.Off); TemperatureControl.Writeable = true; string temperatureUnit = UnitConversionEx.PhysUnitName(UnitConversion.PhysUnitEnum.PhysUnit_Celsius); // °C - localized const int temperaturePrecision = 1; ITypeDouble temperatureType = ddk.CreateDouble(0, 100, temperaturePrecision); temperatureType.Unit = temperatureUnit; TemperatureMin = m_Temperature.CreateStandardProperty(StandardPropertyID.LowerLimit, temperatureType); TemperatureMin.Writeable = true; TemperatureMin.Update(20); TemperatureMax = m_Temperature.CreateStandardProperty(StandardPropertyID.UpperLimit, temperatureType); TemperatureMax.Writeable = true; TemperatureMax.Update(80); TemperatureNominal = m_Temperature.CreateStandardProperty(StandardPropertyID.Nominal, temperatureType); // Desired (requested) temperature TemperatureNominal.Writeable = true; TemperatureNominal.Update(50); temperatureType = ddk.CreateDouble(double.MinValue, double.MaxValue, temperaturePrecision); temperatureType.Unit = temperatureUnit; TemperatureValue = m_Temperature.CreateStandardProperty(StandardPropertyID.Value, temperatureType); TemperatureValue.Update(40); // Set the default read and write properties for the structure m_Temperature.DefaultGetProperty = TemperatureValue; m_Temperature.DefaultSetProperty = TemperatureNominal; }
/// Create our Dionex.Chromeleon.Symbols.IDevice and our Properties internal IDevice Create(IDDK cmDDK, string name) { // Create a device for temperature control m_Device = cmDDK.CreateDevice(name, "Example for a temperature control device"); // Create a type for a temperature logging command ITypeInt tyTempLogParam = cmDDK.CreateInt(0, 2); tyTempLogParam.AddNamedValue("Start", 0); tyTempLogParam.AddNamedValue("Stop", 1); tyTempLogParam.AddNamedValue("Pause", 2); // Create a temperature logging command ICommand logTemperature = m_Device.CreateCommand("LogTemperature", "Switches temperature logging on / off"); // Add a parameter for the tewmperature logging command logTemperature.AddParameter("LogParameter", "Starts, stops or pauses temperature logging", tyTempLogParam); // Create a boolean property to signal if the device is ready for an inject operation. ITypeInt tyReady = cmDDK.CreateInt(0, 1); tyReady.AddNamedValue("False", 0); tyReady.AddNamedValue("True", 1); IProperty readyProp = m_Device.CreateStandardProperty(StandardPropertyID.Ready, tyReady); // Create a data type that represent the activation state of the temperature control. ITypeInt tOnOff = cmDDK.CreateInt((int)TempCtrlState.Off, (int)TempCtrlState.On); tOnOff.AddNamedValue("Off", (int)TempCtrlState.Off); tOnOff.AddNamedValue("On", (int)TempCtrlState.On); // Create a property to activate / deactivate temperature control // This property must be writable m_TempCtrlProperty = m_Device.CreateProperty("TemperatureControl", "Activates /deactivates temperature control", tOnOff); m_TempCtrlProperty.Writeable = true; // Create a struct that holds standard properties for temperature and temperature limits m_TempCtrlStruct = m_Device.CreateStruct("Temperature", "Temperature of Column Oven."); // Create a data type that applies to all temperature properties ITypeDouble tTemperature = cmDDK.CreateDouble(0, 100, 1); tTemperature.Unit = "°C"; // Create a property that holds the current temperature // This property is read-only m_CurrentTempProperty = m_TempCtrlStruct.CreateStandardProperty(StandardPropertyID.Value, tTemperature); // Create a property that holds the nominal temperature // This property must be writeable m_NominalTempProperty = m_TempCtrlStruct.CreateStandardProperty(StandardPropertyID.Nominal, tTemperature); m_NominalTempProperty.Update(30.0); //set default value m_NominalTempProperty.OnSetProperty += new SetPropertyEventHandler(OnSetTemperature); // Create a property that holds the minimal temperature // This property must be writeable m_MinTempProperty = m_TempCtrlStruct.CreateStandardProperty(StandardPropertyID.LowerLimit, tTemperature); m_MinTempProperty.Update(15.0); //set default value m_MinTempProperty.Writeable = true; // Create a property that holds the maximal temperature // This property must be writeable m_MaxTempProperty = m_TempCtrlStruct.CreateStandardProperty(StandardPropertyID.UpperLimit, tTemperature); m_MaxTempProperty.Update(110.0);//set default value m_MaxTempProperty.Writeable = true; // Set the default read and write properties for the struct m_TempCtrlStruct.DefaultSetProperty = m_NominalTempProperty; m_TempCtrlStruct.DefaultGetProperty = m_CurrentTempProperty; // Update property values. They must be readable before the device has been connected. // The device may not be connected when UI-Modules read the default values. m_TempCtrlProperty.Update((int)m_TempCtrl); m_NominalTempProperty.Update(m_NominalTemp); m_MinTempProperty.Update(m_MinTemp); m_MaxTempProperty.Update(m_MaxTemp); m_CurrentTempProperty.Update(m_CurrentTemp); return(m_Device); }
public Pump(IDriverEx driver, IDDK ddk, Config.Pump config, string id) : base(driver, ddk, typeof(Pump).Name, id, config.Name) { Log.TaskBegin(Id); try { m_Properties = new PumpProperties(m_DDK, m_Device); m_Properties.PressureLowerLimit.OnSetProperty += OnPropertyPressureLowerLimitSet; m_Properties.PressureUpperLimit.OnSetProperty += OnPropertyPressureUpperLimitSet; // Properties of the flow handler: // m_FlowHandler.FlowNominalProperty - Flow.Nominal // m_FlowHandler.FlowValueProperty - Flow.Value // m_FlowHandler.ComponentProperties[i] (4 eluent component) - %A.Equate, %B.Equate, %C.Equate, %D.Equate // %A.Valuue, %B.Valuue; %C.Valuue; %D.Valuue ITypeDouble flowType = m_DDK.CreateDouble(0, 10, 3); flowType.Unit = UnitConversionEx.PhysUnitName(UnitConversion.PhysUnitEnum.PhysUnit_MilliLiterPerMin); // ml/min m_FlowHandler = m_Device.CreateFlowHandler(flowType, 4, 2); m_FlowHandler.FlowNominalProperty.OnPreflightSetProperty += OnPropertyFlowNominalSetPreflight; m_FlowHandler.FlowNominalProperty.OnSetProperty += OnPropertyFlowNominalSet; m_FlowHandler.FlowNominalProperty.OnSetRamp += OnPropertyFlowNominalSetRamp; //m_FlowHandler.FlowNominalProperty.RampSyntax = true; // m_FlowHandler.FlowNominalProperty.IsRampSyntax is already True m_FlowHandler.FlowNominalProperty.Update(0); //m_FlowHandler.FlowValueProperty.RampSyntax = true; // m_FlowHandler.FlowValueProperty.IsRampSyntax is already True m_FlowHandler.FlowValueProperty.Update(0); m_EluentPercentA = 100; m_FlowHandler.ComponentProperties[0].Update(m_EluentPercentA); // Partial flow of this component, expressed in percent of the total flow. m_FlowHandler.EquateProperties[i].HelpText = "User-selectable designation of this solvent component." m_FlowHandler.ComponentProperties[1].Update(m_EluentPercentB); m_FlowHandler.ComponentProperties[2].Update(m_EluentPercentC); m_FlowHandler.ComponentProperties[3].Update(m_EluentPercentD); m_FlowHandler.EquateProperties[0].Update("Water"); m_FlowHandler.ComponentProperties[1].OnSetProperty += OnPropertyFlowHandler_ComponentProperty_2_Set; m_FlowHandler.ComponentProperties[2].OnSetProperty += OnPropertyFlowHandler_ComponentProperty_3_Set; m_FlowHandler.ComponentProperties[3].OnSetProperty += OnPropertyFlowHandler_ComponentProperty_4_Set; double pressureSignalMin = m_Properties.PressureLowerLimit.Value.GetValueOrDefault(); double pressureSignalMax = m_Properties.PressureUpperLimit.Value.GetValueOrDefault(); int pressureSignalDigits = 3; string pressureUnitName = m_Properties.PressureValue.DataType.Unit; UnitConversion.PhysUnitEnum pressureUnit = UnitConversionEx.PhysUnitFindName(pressureUnitName); m_ChannelPressure = new PumpChannelPressure(driver, ddk, m_Device, "Channel_Pressure_Id", "Channel_Pressure_Name", pressureSignalMin, pressureSignalMax, pressureSignalDigits, pressureUnit); m_Device.OnBatchPreflightBegin += OnDeviceBatchPreflightBegin; m_Device.OnBatchPreflightSample += OnDeviceBatchPreflightSample; m_Device.OnBatchPreflightEnd += OnDeviceBatchPreflightEnd; m_Device.OnPreflightBegin += OnDevicePreflightBegin; m_Device.OnPreflightLatch += OnDevicePreflightLatch; m_Device.OnPreflightSync += OnDevicePreflightSync; m_Device.OnPreflightBroadcast += OnDevicePreflightBroadcast; m_Device.OnPreflightEnd += OnDevicePreflightEnd; m_Device.OnTransferPreflightToRun += OnDeviceTransferPreflightToRun; m_Device.OnLatch += OnDeviceLatch; m_Device.OnSync += OnDeviceSync; // See these in the AutoSampler m_Device.OnSequenceStart += OnDeviceSequenceStart; m_Device.OnSequenceChange += OnDeviceSequenceChange; m_Device.OnSequenceEnd += OnDeviceSequenceEnd; m_Device.OnBroadcast += OnDeviceBroadcast; Log.TaskEnd(Id); } catch (Exception ex) { Log.TaskEnd(Id, ex); throw; } }
/// <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 the Dionex.Chromeleon.Symbols.IDevice m_MyCmDevice = cmDDK.CreateDevice(name, "This is an example device."); // create a few example properties // A Data type for seconds ranging from 0 - 59 ITypeInt tSeconds = cmDDK.CreateInt(0, 59); tSeconds.Unit = "s"; // Create the "Clock" property m_ClockProperty = m_MyCmDevice.CreateProperty("Clock", "This is a second counter", tSeconds); // Attach the OnSetClockProperty handler to the "Clock" property m_ClockProperty.OnSetProperty += new SetPropertyEventHandler(OnSetClockProperty); // we will use a timer to update the clock property each second // Attach the OnTimedEvent handler to the timer. m_clockTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent); // A Data type with two values 0 and 1 ITypeInt tEnable = cmDDK.CreateInt(0, 1); tEnable.AddNamedValue("false", 0); tEnable.AddNamedValue("true", 1); // Create the "EnableClock" property m_EnableClockProperty = m_MyCmDevice.CreateProperty("EnableClock", "Enable / disable the clock", tEnable); // Attach the OnEnableClock handler to the "EnableClock" property m_EnableClockProperty.OnSetProperty += new SetPropertyEventHandler(OnEnableClock); // A Data type for a percentage ranging from 0.0 - 100.0 ITypeDouble tPercent = cmDDK.CreateDouble(0, 100, 2); tPercent.Unit = "%"; // Create the "Percentage" property m_PercentageProperty = m_MyCmDevice.CreateProperty("Percentage", "This is a percentage property", tPercent); // Attach the OnSetProperty handler to the "Percentage" property m_PercentageProperty.OnSetProperty += new SetPropertyEventHandler(OnSetProperty); // A Data type for a time constant ranging from 1.0 - 10.0 ITypeDouble tTimeConstant = cmDDK.CreateDouble(1.0, 10.0, 1); tTimeConstant.AddNamedValue("Off", 0.0); tTimeConstant.Unit = "s"; // Create the "Percentage" property m_FilterTimeConstantProperty = m_MyCmDevice.CreateProperty("FilterTimeConstant", "This is a numeric property with one special named value.", tTimeConstant); // Attach the OnSetProperty handler to the "FilterTimeConstant" property m_FilterTimeConstantProperty.OnSetProperty += new SetPropertyEventHandler(OnSetProperty); // A Data type for the measurement range property ITypeDouble tMeasurementRange = cmDDK.CreateDouble(0.01, 100.0, 2); tMeasurementRange.LegalValues = new double[] { 0.01, 0.1, 1.0, 10.0, 100.0 }; tMeasurementRange.EnforceLegalValues = true; tMeasurementRange.Unit = "V"; // Create the "Percentage" property m_MeasurementRangeProperty = m_MyCmDevice.CreateProperty("MeasurementRange", "This is a numeric property with 5 legal (valid) values.", tMeasurementRange); // Attach the OnSetProperty handler to the "FilterTimeConstant" property m_MeasurementRangeProperty.OnSetProperty += new SetPropertyEventHandler(OnSetProperty); // A Data type for a string with 20 characters at most ITypeString tString = cmDDK.CreateString(20); // Create the "AnyText" property m_AnyTextProperty = m_MyCmDevice.CreateProperty("AnyText", "This is a string property", tString); // Attach the OnSetProperty handler to the "AnyText" property m_AnyTextProperty.OnSetProperty += new SetPropertyEventHandler(OnSetProperty); // Create the "ToggleEnableClock" example command m_Command = m_MyCmDevice.CreateCommand("ToggleEnableClock", "This is a simple command that toggles the EnableClock property."); // Attach the OnToggleEnableClock handler to the "ToggleEnableClock" command m_Command.OnCommand += new CommandEventHandler(OnToggleEnableClock); // Create the "SetEnableClock" command which uses a parameter. m_SetEnableClockCommand = m_MyCmDevice.CreateCommand("SetEnableClock", "This is a command with one required parameter. Set true or false to enable/disable the clock."); // Add the "Enable" parameter to the "SetEnableClock" command IParameter parameter = m_SetEnableClockCommand.AddParameter("Enable", "Set true or false to enable/disable the clock", tEnable); // This is a required parameter. parameter.Required = true; // Attach the OnSetEnableClock handler to the "SetEnableClock" command m_SetEnableClockCommand.OnCommand += new CommandEventHandler(OnSetEnableClock); // Create the "SetPercentage" command which uses a parameter. m_SetPercentageCommand = m_MyCmDevice.CreateCommand("SetPercentage", "This is a command with one required parameter to set the \"Percentage\" property."); // Add the "Value" parameter to the "SetPercentage" command parameter = m_SetPercentageCommand.AddParameter("Value", "Set to 0.00 - 100.00", tPercent); // This is a required parameter. parameter.Required = true; // Attach the OnSetPercentage handler to the "SetPercentage" command m_SetPercentageCommand.OnCommand += new CommandEventHandler(OnSetPercentage); // Create the "CommandWith4Parameters" command which uses 4 optional parameters. m_CommandWith4Parameters = m_MyCmDevice.CreateCommand("CommandWith4Parameters", "This is a command with four optional parameters."); // Add the parameters to the "CommandWith4Parameters" command m_CommandWith4Parameters.AddParameter("Param1", "Set true or false", tEnable); m_CommandWith4Parameters.AddParameter("Param2", "Set to 0.00 - 100.00", tPercent); m_CommandWith4Parameters.AddParameter("Param3", "Set true or false", tEnable); m_CommandWith4Parameters.AddParameter("Param4", "A string with 20 characters", tString); // Attach the OnCommandWith4Parameters handler to the "CommandWith4Parameters" command m_CommandWith4Parameters.OnCommand += new CommandEventHandler(OnCommandWith4Parameters); return(m_MyCmDevice); }
/// <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 the Dionex.Chromeleon.Symbols.IDevice m_MyCmDevice = cmDDK.CreateDevice(name, "This is an example device."); // create a few example properties // A Data type for a flow ranging from 0.000 - 10.000 ITypeDouble tFlow = cmDDK.CreateDouble(0, 10, 3); tFlow.Unit = "ml/min"; // Create our flow handler. The flow handler creates a Flow.Nominal, // a Flow.Value and 2 eluent component properties for us. m_FlowHandler = m_MyCmDevice.CreateFlowHandler(tFlow, 2, 2); // initialize the flow m_FlowHandler.FlowNominalProperty.Update(0); // initialize the components m_FlowHandler.ComponentProperties[0].Update(100.0); m_FlowHandler.ComponentProperties[1].Update(0); // All properties support ramps m_FlowHandler.FlowNominalProperty.RampSyntax = true; m_FlowHandler.ComponentProperties[0].RampSyntax = true; m_FlowHandler.ComponentProperties[1].RampSyntax = true; // Attach various handlers m_FlowHandler.FlowNominalProperty.OnSetProperty += new SetPropertyEventHandler(m_RampedFlowProperty_OnSetProperty); m_FlowHandler.ComponentProperties[1].OnSetProperty += new SetPropertyEventHandler(m_RampedPercentageProperty_OnSetProperty); m_FlowHandler.FlowNominalProperty.OnSetRamp += new SetRampEventHandler(m_RampedFlowProperty_OnSetRamp); m_FlowHandler.ComponentProperties[1].OnSetRamp += new SetRampEventHandler(m_RampedPercentageProperty_OnSetRamp); m_FlowHandler.FlowNominalProperty.OnPreflightSetProperty += new SetPropertyEventHandler(m_RampedFlowProperty_OnPreflightSetProperty); m_FlowHandler.ComponentProperties[1].OnPreflightSetProperty += new SetPropertyEventHandler(m_RampedPercentageProperty_OnPreflightSetProperty); m_FlowHandler.FlowNominalProperty.OnPreflightSetRamp += new SetRampEventHandler(m_RampedFlowProperty_OnPreflightSetRamp); m_FlowHandler.ComponentProperties[1].OnPreflightSetRamp += new SetRampEventHandler(m_RampedPercentageProperty_OnPreflightSetRamp); m_MyCmDevice.OnSetTimeTable += new SetTimeTableEventHandler(m_MyCmDevice_OnSetTimeTable); m_MyCmDevice.OnPreflightSetTimeTable += new SetTimeTableEventHandler(m_MyCmDevice_OnPreflightSetTimeTable); // now create the properties and command for valve simulation ITypeInt valvePropType = cmDDK.CreateInt(1, 2); valvePropType.LegalValues = new[] { 1, 2 }; m_ValveState = m_MyCmDevice.CreateProperty("ValveState", "The state of the simulated valve, can be '1' or '2'.", valvePropType); m_ValveState.OnSetProperty += new SetPropertyEventHandler(m_ValveState_OnSetProperty); m_ValveState.OnPreflightSetProperty += new SetPropertyEventHandler(m_ValveState_OnPreflightSetProperty); m_ValveCommandTo1 = m_MyCmDevice.CreateCommand("SwitchValveTo1", "Switch the simulated valve to '1' state."); m_ValveCommandTo1.OnCommand += new CommandEventHandler(m_ValveCommandTo1_OnCommand); m_ValveCommandTo1.OnPreflightCommand += new CommandEventHandler(m_ValveCommandTo1_OnPreflightCommand); m_ValveCommandTo2 = m_MyCmDevice.CreateCommand("SwitchValveTo2", "Switch the simulated valve to '2' state."); m_ValveCommandTo2.OnCommand += new CommandEventHandler(m_ValveCommandTo2_OnCommand); m_ValveCommandTo2.OnPreflightCommand += new CommandEventHandler(m_ValveCommandTo2_OnPreflightCommand); m_ValveCommandWithPar = m_MyCmDevice.CreateCommand("SwitchValve", "Switch the simulated valve according to parameters."); m_ValveStateParameter = m_ValveCommandWithPar.AddParameter("NewState", "The new state of the simulated valve, can be '1' or '2'.", valvePropType); m_ValveStateParameter.Required = true; m_ValveLogParameter = m_ValveCommandWithPar.AddParameter("Message", "A message to be written when executing the command.", m_MyCmDDK.CreateString(64)); m_ValveLogParameter.Required = false; m_ValveCommandWithPar.OnCommand += new CommandEventHandler(m_ValveCommandWithPar_OnCommand); m_ValveCommandWithPar.OnPreflightCommand += new CommandEventHandler(m_ValveCommandWithPar_OnPreflightCommand); return(m_MyCmDevice); }
/// Create our Chromeleon symbols internal IPDAChannel OnCreate(IDDK cmDDK, IDevice master, string name) { // Create a data type for the wavelength range ITypeDouble tWavelength = cmDDK.CreateDouble(200.0, 600.0, 1); tWavelength.Unit = "nm"; // Create a data type for the reference wavelength range ITypeDouble tRefWavelength = cmDDK.CreateDouble(200.0, 600.0, 1); tRefWavelength.Unit = "nm"; tRefWavelength.AddNamedValue("Off", 0.0); // Create a data type for the reference bandwidth ITypeDouble tReferenceBandwidth = cmDDK.CreateDouble(0.0, 20.0, 1); tReferenceBandwidth.Unit = "nm"; // Create a data type for the bunch width ITypeDouble tBunchWidth = cmDDK.CreateDouble(0.0, 10.0, 1); tBunchWidth.Unit = "nm"; // Create the channel symbol m_MyCmDevice = cmDDK.CreatePDAChannel(name, "This is a channel that can generate a spectrum.", tWavelength, tRefWavelength, tReferenceBandwidth, tBunchWidth, 400, PDAWriteMode.AbsorbanceDirect); // We will be a subdevice of the master device m_MyCmDevice.SetOwner(master); // Attach our handlers to the AcquisitionOffCommand and AcquisitionOnCommand of the channel m_MyCmDevice.AcquisitionOffCommand.OnCommand += new CommandEventHandler(OnAcqOff); m_MyCmDevice.AcquisitionOnCommand.OnCommand += new CommandEventHandler(OnAcqOn); m_MyCmDevice.OnDataFinished += new DataFinishedEventHandler(m_MyCmDevice_OnDataFinished); // Usually, TimeStepFactor and TimeStepFactor are read-only properties and the driver updates them. // In this driver we allow to change these values manually for illustration purposes. m_MyCmDevice.TimeStepFactorProperty.DataType.Minimum = 1; m_MyCmDevice.TimeStepFactorProperty.DataType.Maximum = 10000; m_MyCmDevice.TimeStepFactorProperty.OnSetProperty += new SetPropertyEventHandler(TimeStepFactorProperty_OnSetProperty); m_MyCmDevice.TimeStepDivisorProperty.DataType.Minimum = 1; m_MyCmDevice.TimeStepDivisorProperty.DataType.Maximum = 10000; m_MyCmDevice.TimeStepDivisorProperty.OnSetProperty += new SetPropertyEventHandler(TimeStepDivisorProperty_OnSetProperty); ITypeDouble tRateType = cmDDK.CreateDouble(0.1, 1000.0, 1); tRateType.Unit = "Hz"; m_RateProperty = m_MyCmDevice.CreateProperty("FixedRate", "The data collection rate in Hz.", tRateType); m_RateProperty.OnSetProperty += new SetPropertyEventHandler(m_RateProperty_OnSetProperty); ITypeInt tDataIndexType = cmDDK.CreateInt(0, int.MaxValue); m_SpectraIndexProperty = m_MyCmDevice.CreateProperty("TotalSpectra", "Total number of spectra.", tDataIndexType); ICommand noMoreDataCommand = m_MyCmDevice.CreateCommand("NoMoreData", "Send IChannel.NoMoreData to stop data acquisition immediately."); noMoreDataCommand.OnCommand += new CommandEventHandler(noMoreDataCommand_OnCommand); ITypeDouble tChannelTimeType = cmDDK.CreateDouble(0, 1000, 3); tChannelTimeType.Unit = "min"; m_ChannelTimeProperty = m_MyCmDevice.CreateProperty("ChannelTime", "Internal time of the channel.", tChannelTimeType); return(m_MyCmDevice); }
/// Create our Chromeleon symbols internal IChannel OnCreate(IDDK cmDDK, IDevice master, string name) { // Create a data type for our signal ITypeDouble tSignal = cmDDK.CreateDouble(-100.0, 100.0, 1); tSignal.Unit = "mV"; // Create the channel symbol m_MyCmDevice = cmDDK.CreateChannel(name, "This is a channel that can generate a sinus curve.", tSignal); // We will be a subdevice of the master device m_MyCmDevice.SetOwner(master); // Attach our handlers to the AcquisitionOffCommand and AcquisitionOnCommand of the channel m_MyCmDevice.AcquisitionOffCommand.OnCommand += new CommandEventHandler(OnAcqOff); m_MyCmDevice.AcquisitionOnCommand.OnCommand += new CommandEventHandler(OnAcqOn); m_MyCmDevice.OnDataFinished += new DataFinishedEventHandler(m_MyCmDevice_OnDataFinished); // Usually, TimeStepFactor and TimeStepFactor are read-only properties and the driver updates them. // In this driver we allow to change these values manually for illustration purposes. m_MyCmDevice.TimeStepFactorProperty.DataType.Minimum = 1; m_MyCmDevice.TimeStepFactorProperty.DataType.Maximum = 10000; m_MyCmDevice.TimeStepFactorProperty.OnSetProperty += new SetPropertyEventHandler(TimeStepFactorProperty_OnSetProperty); m_MyCmDevice.TimeStepDivisorProperty.DataType.Minimum = 1; m_MyCmDevice.TimeStepDivisorProperty.DataType.Maximum = 10000; m_MyCmDevice.TimeStepDivisorProperty.OnSetProperty += new SetPropertyEventHandler(TimeStepDivisorProperty_OnSetProperty); ITypeDouble tRateType = cmDDK.CreateDouble(0.1, 1000.0, 1); tRateType.Unit = "Hz"; m_RateProperty = m_MyCmDevice.CreateProperty("FixedRate", "The data collection rate in Hz.", tRateType); m_RateProperty.OnSetProperty += new SetPropertyEventHandler(m_RateProperty_OnSetProperty); // We want to have the FixedRate available as a report variable and therefore add it to the channel info. m_MyCmDevice.AddPropertyToChannelInfo(m_RateProperty); ITypeInt tDataIndexType = cmDDK.CreateInt(0, int.MaxValue); m_DataIndexProperty = m_MyCmDevice.CreateProperty("TotalDataPoints", "Total number of data points.", tDataIndexType); ICommand noMoreDataCommand = m_MyCmDevice.CreateCommand("NoMoreData", "Send IChannel.NoMoreData to stop data acquisition immediately."); noMoreDataCommand.OnCommand += new CommandEventHandler(noMoreDataCommand_OnCommand); ITypeDouble tChannelTimeType = cmDDK.CreateDouble(0, 1000, 3); tChannelTimeType.Unit = "min"; m_ChannelTimeProperty = m_MyCmDevice.CreateProperty("ChannelTime", "Internal time of the channel.", tChannelTimeType); // What do we actually measure? m_MyCmDevice.PhysicalQuantity = "MotorCurrent"; // This channel doesn't have peaks, we don't want to have it integrated. m_MyCmDevice.NeedsIntegration = false; // Create a command for writing a spectrum ICommand writeSpectrumCommand = m_MyCmDevice.CreateCommand("WriteSpectrum", "Write a spectrum"); writeSpectrumCommand.OnCommand += new CommandEventHandler(OnWriteSpectrum); // Create an interface for spectrum writing m_SpectrumWriter = m_MyCmDevice.CreateSpectrumWriter(); return(m_MyCmDevice); }