private void m_ValveCommandWithPar_OnPreflightCommand(CommandEventArgs args)
{
string stateValueFormatted = "<noValue>";
string logValueFormatted = "<noValue>";
IIntParameterValue stateValue = args.ParameterValue(m_ValveStateParameter) as IIntParameterValue;
if ((stateValue != null) && stateValue.Value.HasValue)
{
stateValueFormatted = stateValue.Value.Value.ToString(CultureInfo.InvariantCulture);
}
IStringParameterValue logValue = args.ParameterValue(m_ValveLogParameter) as IStringParameterValue;
if ((logValue != null) && !String.IsNullOrEmpty(logValue.Value))
{
logValueFormatted = logValue.Value;
}
// Write a message to the preflight results
String message = String.Format(CultureInfo.InvariantCulture, "m_ValveCommandWithPar_OnPreflightCommand(time: {0}, state {1}, log {2})", RetentionToString(args.RetentionTime), stateValueFormatted, logValueFormatted);
#if (PreflightMessagesToCM)
m_MyCmDevice.AuditMessage(AuditLevel.Warning, message);
#else
Debug.WriteLine("PreflightMessage: " + message);
#endif
}
/// <summary>
/// Called when the SwitchValve command is triggered by Chromeleon.
/// </summary>
/// <param name="args">The CommandEventArgs contain the parameter values.</param>
private void m_ValveCommandWithPar_OnCommand(CommandEventArgs args)
{
IIntParameterValue stateValue = args.ParameterValue(m_ValveStateParameter) as IIntParameterValue;
if ((stateValue == null) || !stateValue.Value.HasValue)
{
m_MyCmDevice.AuditMessage(AuditLevel.Error, "ValveState is a required parameter, should have a value!");
return;
}
IStringParameterValue logValue = args.ParameterValue(m_ValveLogParameter) as IStringParameterValue;
if ((logValue != null) && !String.IsNullOrEmpty(logValue.Value))
{
// Write a the message from command parameter to the audit trail
m_MyCmDevice.AuditMessage(AuditLevel.Message, logValue.Value);
}
else
{
// Write a default message to the audit trail
String message = String.Format(CultureInfo.InvariantCulture, "m_ValveCommandWithPar_OnCommand(time: {1}, state {0})", stateValue.Value.Value, RetentionToString(args.RetentionTime));
m_MyCmDevice.AuditMessage(AuditLevel.Message, message);
}
// As we simulate the valve only, we update the property direcly.
m_ValveState.Update(stateValue.Value.Value);
}
/// <summary>
/// Called on "Inject" command
/// </summary>
/// <param name="args"></param>
private void OnInject(CommandEventArgs args)
{
IDoubleParameterValue vVolume =
args.ParameterValue(m_InjectHandler.InjectCommand.FindParameter("Volume"))
as IDoubleParameterValue;
if (vVolume != null && vVolume.Value.HasValue)
{
m_Volume = vVolume.Value.Value;
m_InjectHandler.VolumeProperty.Update(m_Volume);
}
IIntParameterValue vPosition =
args.ParameterValue(m_InjectHandler.InjectCommand.FindParameter("Position"))
as IIntParameterValue;
if (vPosition != null && vPosition.Value.HasValue)
{
m_Position = vPosition.Value.Value;
m_InjectHandler.PositionProperty.Update(m_Position);
}
m_MyCmDevice.AuditMessage(AuditLevel.Message,
"Injecting " + m_Volume.ToString() +
" ml from Position: " + m_Position.ToString());
// Start the injection timer that will generate the inject response after
// after 20 seconds delay.
m_InjectionTimer.Start();
}
private static IParameterValue GetParameterValue(CommandEventArgs args, string paramName, bool throwException)
{
if (args == null)
{
throw new ArgumentNullException("args");
}
if (args.Command == null)
{
throw new ArgumentNullException("args.Command");
}
IParameter parameter = args.Command.FindParameter(paramName);
if (parameter == null)
{
if (throwException)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resources.CommandParameterNotProvided, args.Command.Name, paramName));
}
return(null);
}
IParameterValue result = args.ParameterValue(parameter);
if (result == null)
{
if (throwException)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resources.CommandParameterValueNotFound, args.Command.Name, paramName));
}
return(null);
}
return(result);
}
private void OnInject(CommandEventArgs args)
{
IDoubleParameterValue vVolume =
args.ParameterValue(m_InjectHandler.InjectCommand.FindParameter("Volume"))
as IDoubleParameterValue;
if (vVolume != null && vVolume.Value.HasValue)
{
m_Volume = vVolume.Value.Value;
m_InjectHandler.VolumeProperty.Update(m_Volume);
}
IIntParameterValue vPosition =
args.ParameterValue(m_InjectHandler.InjectCommand.FindParameter("Position"))
as IIntParameterValue;
if (vPosition != null && vPosition.Value.HasValue)
{
m_Position = vPosition.Value.Value;
m_InjectHandler.PositionProperty.Update(m_Position);
}
// Collect information from the injection table to display it
StringBuilder sb = new StringBuilder("RunningSample:\n");
sb.Append("RunningIndex=" + m_CurrentSequence.RunningIndex.ToString() + "\n");
sb.Append("Position=" + m_CurrentSequence.RunningSample.Position + "\n");
sb.Append("Number=" + m_CurrentSequence.RunningSample.Number + "\n");
sb.Append("ID=" + m_CurrentSequence.RunningSample.ID + "\n");
sb.Append("Type=" + m_CurrentSequence.RunningSample.SampleType.ToString() + "\n");
m_MyCmDevice.AuditMessage(AuditLevel.Message, sb.ToString());
m_MyCmDevice.AuditMessage(AuditLevel.Message,
"Injecting " + m_Volume.ToString() +
" ml from Position: " + m_Position.ToString());
Thread.Sleep(5000);
m_MyCmDevice.AuditMessage(AuditLevel.Message, "Injection done.");
m_InjectHandler.NotifyInjectResponse();
}
private void OnInject(CommandEventArgs args)
{
m_ReadyProperty.Update(0); //set ready state to not ready
IDoubleParameterValue vVolume =
args.ParameterValue(m_InjectHandler.InjectCommand.FindParameter("Volume"))
as IDoubleParameterValue;
if (vVolume != null && // if this parameter is set...
vVolume.Value.HasValue) // ... to some value
{
m_Volume = vVolume.Value.Value;
m_InjectHandler.VolumeProperty.Update(m_Volume);
}
IIntParameterValue vPosition =
args.ParameterValue(m_InjectHandler.InjectCommand.FindParameter("Position"))
as IIntParameterValue;
if (vPosition != null && // if this parameter is set...
vPosition.Value.HasValue) // ... to some value
{
m_Position = vPosition.Value.Value;
m_InjectHandler.PositionProperty.Update(m_Position);
}
m_Device.AuditMessage(AuditLevel.Message,
"Injecting " + m_Volume.ToString() +
" ml from Position: " + m_Position.ToString());
// The injection takes a while...
Thread.Sleep(5000);
m_Device.AuditMessage(AuditLevel.Message, "Injection done.");
// After the injection has finished, we send the inject response.
m_InjectHandler.NotifyInjectResponse();
}
/// <summary>
/// Called when the "SetPercentage" command is sent by Chromeleon.
/// </summary>
/// <param name="args">The CommandEventArgs contain a reference to
/// the command being called and the argument list.</param>
private void OnSetPercentage(CommandEventArgs args)
{
Debug.Assert(args.Command == m_SetPercentageCommand);
// Get the parameter
IDoubleParameterValue percentValue =
args.ParameterValue(m_SetPercentageCommand.FindParameter("Value")) as IDoubleParameterValue;
Debug.Assert(percentValue != null, "Required parameter is missing!");
Debug.Assert(percentValue.Value.HasValue);
double newValue = percentValue.Value.Value;
// We use the OnSetProperty handler to set the property. This avoids code duplication.
// The last two parameters are not used by our handler, so it is safe to set them to null.
SetDoublePropertyEventArgs doubleArgs =
new SetDoublePropertyEventArgs(m_PercentageProperty, newValue, null, null);
OnSetProperty(doubleArgs);
}
/// <summary>
/// Called when the "SetEnableClock" command is sent by Chromeleon.
/// </summary>
/// <param name="args">The CommandEventArgs contain a reference to
/// the command being called and the argument list.</param>
private void OnSetEnableClock(CommandEventArgs args)
{
Debug.Assert(args.Command == m_SetEnableClockCommand);
// Get the parameter
IIntParameterValue enableValue =
args.ParameterValue(m_SetEnableClockCommand.FindParameter("Enable")) as IIntParameterValue;
Debug.Assert(enableValue != null, "Required parameter is missing!");
Debug.Assert(enableValue.Value.HasValue);
int newValue = enableValue.Value.Value;
// We use the OnEnableClock handler to set the property. This avoids code duplication.
// The last two parameters are not used by our handler, so it is safe to set them to null.
SetIntPropertyEventArgs intArgs =
new SetIntPropertyEventArgs(m_EnableClockProperty, newValue, null, null);
OnEnableClock(intArgs);
}
/// <summary>
/// Called when the "CommandWith4Parameters" command is sent by Chromeleon.
/// </summary>
/// <param name="args">The CommandEventArgs contain a reference to
/// the command being called and the argument list.</param>
private void OnCommandWith4Parameters(CommandEventArgs args)
{
Debug.Assert(args.Command == m_CommandWith4Parameters);
// This command does not really do anything but retrieving the different parameters
// and showing them in the audit trail.
StringBuilder sb = new StringBuilder("CommandWith4Parameters was called with the following parameters:");
// check for Param1
IIntParameterValue param1Value =
args.ParameterValue(m_CommandWith4Parameters.FindParameter("Param1")) as IIntParameterValue;
sb.Append("\nParam1=");
if (param1Value != null)
{
sb.Append(param1Value.Value);
}
else
{
sb.Append("<not set>");
}
// check for Param2
IDoubleParameterValue param2Value =
args.ParameterValue(m_CommandWith4Parameters.FindParameter("Param2")) as IDoubleParameterValue;
sb.Append("\nParam2=");
if (param2Value != null)
{
sb.Append(param2Value.Value);
}
else
{
sb.Append("<not set>");
}
// check for Param3
IIntParameterValue param3Value =
args.ParameterValue(m_CommandWith4Parameters.FindParameter("Param3")) as IIntParameterValue;
sb.Append("\nParam3=");
if (param3Value != null)
{
sb.Append(param3Value.Value);
}
else
{
sb.Append("<not set>");
}
// check for Param4
IStringParameterValue param4Value =
args.ParameterValue(m_CommandWith4Parameters.FindParameter("Param4")) as IStringParameterValue;
sb.Append("\nParam4=");
if (param4Value != null)
{
sb.Append(param4Value.Value);
}
else
{
sb.Append("<not set>");
}
m_MyCmDevice.AuditMessage(AuditLevel.Message, sb.ToString());
}
