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);
}
/// <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);
}
/// 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 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);
}
/// <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);
}
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);
}
internal void Create(IDDK cmDDK, string deviceName)
{
m_DDK = cmDDK;
m_Device = m_DDK.CreateDevice(deviceName, "LCSystem device. This is our master device.");
IStringProperty typeProperty =
m_Device.CreateProperty("DeviceType",
"The DeviceType property tells us which component we are talking to.",
m_DDK.CreateString(20));
typeProperty.Update("LCSystem");
}
/// We will create our properties in here.
internal IDevice Create(IDDK cmDDK, string name)
{
m_MyCmDevice = cmDDK.CreateDevice(name, "Relay");
ITypeInt tState = cmDDK.CreateInt(0, 1);
m_PropState = m_MyCmDevice.CreateProperty("State",
"Indicates or sets the relay's state.",
tState);
m_PropState.OnSetProperty += new SetPropertyEventHandler(OnSetState);
return(m_MyCmDevice);
}
/// Create our Dionex.Chromeleon.Symbols.IDevice and our Property
internal IDevice Create(IDDK cmDDK, string name)
{
// Create our Dionex.Chromeleon.Symbols.IDevice
m_MyCmDevice = cmDDK.CreateDevice(name, "SendReceive DDK Example.");
// Create the standard Property containing our model number
// There are standard properties with a special meaning for CM and a simplified
// syntax. For details, see the documentation.
m_ModelNoProperty =
m_MyCmDevice.CreateStandardProperty(StandardPropertyID.ModelNo, cmDDK.CreateString(20));
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)
{
// 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);
}
/// <summary>
/// Create the 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 a device using an embedded binary data block (blob).");
// Let the DDK create a data block id.
// This id will be associated with the driver id and the symbol name of your driver instance.
m_BlobDataID = m_MyCmDevice.CreateBlobId("MyBlobDataType");
// Attach to TransferPreflightToRun and OnPreflightEnd in order to report the content of the blob to the audit trail.
m_MyCmDevice.OnTransferPreflightToRun += OnTransferPfToRun;
m_MyCmDevice.OnPreflightEnd += OnPreflightEnd;
m_MyCmDevice.StoreAdditionalInformation("AdditionalInformation1");
cmDDK.AuditMessage(AuditLevel.Normal, m_MyCmDevice.GetAdditionalInformation());
m_MyCmDevice.CustomData = "Some custom data, here, a string, but could be any object";
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)
{
// Load the help text from the resource
string deviceHelpText =
Properties.Resources.LocalizedDevice_HelpText;
// Create our Dionex.Chromeleon.Symbols.IDevice
m_MyCmDevice = cmDDK.CreateDevice(name, deviceHelpText);
// Load the help text from the resource
string statusPropertyText =
Properties.Resources.StatusProperty_HelpText;
// create a test Property containing a string
m_statusProperty =
m_MyCmDevice.CreateProperty("Status", statusPropertyText, cmDDK.CreateString(20));
m_statusProperty.Update("Disconnected.");
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="driver">The driver instance</param>
/// <param name="name">The name for our device</param>
/// <returns>our IDevice object</returns>
internal IDevice OnCreate(ChannelTestDriver driver, IDDK cmDDK, string name)
{
m_Driver = driver;
// Create our Dionex.Chromeleon.Symbols.IDevice
m_MyCmDevice = cmDDK.CreateDevice(name, "This is the master device of the ChannelTest driver.");
m_MyCmDevice.ImmediateNotReady = true;
// NOTE:
// Setting 'ImmediateNotReady' to true on the main device toggles the 'Ready' property for 5s(default) to false when entering TransferPreflightToRun, unless one updates the ready property explicitly.
// Therefore it's also necessary to create a standard property 'Ready' which can be toggled and which can be added to instrument methods in a Wait statement.
// More background:
// In common LC/GC environments an injector is used in the instrument configuration and it's Inject command in the method would cause a natural delay.
// In our example driver we have no delay like this and can run into a kind of data exchange delay issue.
// Setting the parameter FixedRate in a method updates also the channel parameters TimeStepFactorProperty and TimeStepDevisorProperty.
// If setting the parameter FixedRate is immediately followed by an AcqOn command, the 'Real Time Kernel' might not be updated via interprocess communication soon enough and
// calculates the number of expected datapoints with old settings of TimeStepFactorProperty and TimeStepDevisorProperty. This might stop the data acquisition by 'OnDataFinished' when faulty 'enough' data points have been dumped.
// To avoid this in this example, following to steps in combination are necessary:
// 1) introducing a standard property 'Ready' which can be checked in the instrument method.
// 2) Set ChannelTest.ImmediateNotReady to true
// 3) Adding a Wait ChannelTest.Ready in the method before AcqOn.
// This provides enough time when setting FixedRate in our example to update the 'Real Time Kernel's TimeStepFactorProperty and TimeStepDevisorProperty.
// Create a command for the hardware error simulation.
m_HardwareErrorCommand =
m_MyCmDevice.CreateCommand("HardwareError", "This command simulates a hardware error.");
m_HardwareErrorCommand.OnCommand += new CommandEventHandler(m_HardwareErrorCommand_OnCommand);
//Create ready property
ITypeInt tReady = cmDDK.CreateInt(0, 1);
//Add named values
tReady.AddNamedValue("NotReady", 0);
tReady.AddNamedValue("Ready", 1);
ReadyProperty = m_MyCmDevice.CreateStandardProperty(StandardPropertyID.Ready, tReady);
ReadyProperty.Update(1);
return(m_MyCmDevice);
}
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);
}
/// <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 my first DDK device.");
m_MyStringProperty =
m_MyCmDevice.CreateProperty("MyStringProperty", "A string property", cmDDK.CreateString(5));
m_MyStringProperty.OnSetProperty += new SetPropertyEventHandler(m_MyStringProperty_OnSetProperty);
m_MyStringProperty.OnPreflightSetProperty += m_MyStringProperty_OnPreflightSetProperty;
// Create a Property of type double.
m_MyDoubleProperty =
m_MyCmDevice.CreateProperty("MyDoubleProperty", "This is my first property", cmDDK.CreateDouble(0, 20, 2));
// Set the property to writable.
m_MyDoubleProperty.Writeable = true;
// And provide a handler that gets called when the property is assigned.
m_MyDoubleProperty.OnSetProperty += new SetPropertyEventHandler(m_MyDoubleProperty_OnSetProperty);
// Update all properties that have to be readable before the device is connected.
m_MyDoubleProperty.Update(20.0);
// Create a Property of type int.
m_MyIntProperty =
m_MyCmDevice.CreateProperty("MyIntProperty", "This is my second property", cmDDK.CreateInt(-1, 2));
// Set the property to read-only.
m_MyIntProperty.Writeable = false;
// No value known until the device is connected.
m_MyIntProperty.Update(null);
CreateMoreProperties(cmDDK);
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)
{
// Create our Dionex.Chromeleon.Symbols.IDevice
m_MyCmDevice = cmDDK.CreateDevice(name, "This is download device.");
// Create two event properties. These properties may be switched several times during
// an instrument method. Before the run is started all timed events must be collected into
// a download method.
m_EventAProperty =
m_MyCmDevice.CreateBooleanProperty("EventA", "An event property.", "Off", "On");
// We need to set Writeable to allow CM to change the value. If we had a handler
// for the property, this would happen automatically.
m_EventAProperty.Writeable = true;
m_EventBProperty =
m_MyCmDevice.CreateBooleanProperty("EventB", "An event property.", "Off", "On");
m_EventBProperty.Writeable = true;
// The complete method will be sent to the hardware in one go in the OnTransferPfToRun handler.
m_MyCmDevice.OnTransferPreflightToRun += new PreflightEventHandler(OnTransferPfToRun);
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);
}
/// <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);
}
public Device(IDriverEx driver, IDDK ddk, string deviceType, string id, string name, IDevice owner = null, IDevice device = null)
{
if (driver == null)
{
throw new ArgumentNullException("driver");
}
if (ddk == null)
{
throw new ArgumentNullException("ddk");
}
if (string.IsNullOrEmpty(deviceType))
{
throw new ArgumentNullException("deviceType");
}
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException("id");
}
if (id.Length != id.Trim().Length)
{
throw new ArgumentException("id \"" + id + "\" is invalid - it starts or ends with a space");
}
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
if (name.Length != name.Trim().Length)
{
throw new ArgumentException("name \"" + name + "\" is invalid - it starts or ends with a space");
}
m_Driver = driver;
m_DDK = ddk;
m_Id = id;
m_Name = name;
Log.TaskBegin(Id, "Name = \"" + Name + "\"");
try
{
m_IsSimulated = m_Driver.IsSimulated;
m_Device = device;
if (m_Device == null)
{
m_Device = m_DDK.CreateDevice(Name, "Help text for device " + Id + " with name \"" + Name + "\"");
}
if (owner != null)
{
m_Device.SetOwner(owner);
}
m_Properties = new DeviceProperties(m_DDK, m_Device, Id, deviceType, Name);
m_Properties.Description.OnPreflightSetProperty += OnPropertyDescriptionSetPreflight;
m_Properties.Description.OnSetProperty += OnPropertyDescriptionSet;
// The Debug.Assert problem fixed in VS 2017, but the debugger must be already attached - else nothing happens
Debug.Assert(!string.IsNullOrEmpty(Name));
bool debuggerBreak = false;
if (debuggerBreak)
{
DebuggerBreak("Test debugger break");
}
bool breakIfDebuggerIsAttached = false;
if (breakIfDebuggerIsAttached)
{
DebuggerBreakIfIsAttached("Test debugger break is it's attached");
}
Log.TaskEnd(Id);
}
catch (Exception ex)
{
Log.TaskEnd(Id, ex);
throw;
}
}
/// 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);
}
