//-------------------------------------------------------------------------------------------------//
public override string ExecuteXmlRequest(string xmlRequest)
{
string strXmlResponse = string.Empty;
const string STRLOG_MethodName = "ExecuteXmlRequest";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
EquipmentEngine equipmentEngine = (EquipmentEngine)this.labEquipmentEngine;
try
{
bool success = true;
string errorMessage = string.Empty;
CommandInfo commandInfo = null;
CommandInfo resultInfo = null;
//
// Create the XML response
//
XmlDocument xmlResponseDocument = new XmlDocument();
XmlElement xmlElement = xmlResponseDocument.CreateElement(Engine.Consts.STRXML_Response);
xmlResponseDocument.AppendChild(xmlElement);
//
// Add success of command execution and update later
//
xmlElement = xmlResponseDocument.CreateElement(Engine.Consts.STRXML_RspSuccess);
xmlElement.InnerText = success.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
//
// Parse XML request for the command
//
XmlDocument xmlRequestDocument = new XmlDocument();
xmlRequestDocument.LoadXml(xmlRequest);
XmlNode xmlRequestNode = XmlUtilities.GetXmlRootNode(xmlRequestDocument, Engine.Consts.STRXML_Request);
string strCommand = XmlUtilities.GetXmlValue(xmlRequestNode, Engine.Consts.STRXML_Command, false);
NonExecuteCommands nonExecuteCommand = (NonExecuteCommands)(-1);
ExecuteCommands executeCommand = (ExecuteCommands)(-1);
try
{
//
// Try to convert to a non-execute command type that doesn't require powerdown to be suspended
//
nonExecuteCommand = (NonExecuteCommands)Enum.Parse(typeof(NonExecuteCommands), strCommand);
Logfile.Write(STRLOG_Command + nonExecuteCommand.ToString());
}
catch
{
try
{
//
// Try to convert to an execute command type that does require powerdown to be suspended
//
executeCommand = (ExecuteCommands)Enum.Parse(typeof(ExecuteCommands), strCommand);
Logfile.Write(STRLOG_Command + executeCommand.ToString());
//
// Check that powerdown has been suspended before executing the command
//
if (this.labEquipmentEngine.IsPowerdownSuspended == false)
{
//
// Suspend the powerdown before executing the command
//
this.labEquipmentEngine.SuspendPowerdown();
}
}
catch
{
//
// Unknown command
//
success = false;
errorMessage = STRERR_UnknownCommand + strCommand;
}
}
if (success == true && nonExecuteCommand != (NonExecuteCommands)(-1))
{
//
// Process the non-execute command
//
switch (nonExecuteCommand)
{
case NonExecuteCommands.GetTimeToDoSomething:
// Remove this command in your implementation
break;
}
}
else if (success == true && executeCommand != (ExecuteCommands)(-1))
{
//
// Only one execute command allowed at a time
//
lock (this.managerLock)
{
//
// Create an instance of the command info ready to fill in
//
commandInfo = new CommandInfo(executeCommand);
//
// Process the execute command
//
switch (executeCommand)
{
case ExecuteCommands.DoSomething:
// Remove this command in your implementation
break;
}
success = resultInfo.success;
errorMessage = resultInfo.errorMessage;
}
}
//
// Update success of command execution
//
XmlNode xmlResponseNode = XmlUtilities.GetXmlRootNode(xmlResponseDocument, Engine.Consts.STRXML_Response);
XmlUtilities.SetXmlValue(xmlResponseNode, Engine.Consts.STRXML_RspSuccess, success.ToString(), false);
if (success == false)
{
//
// Create error response
//
xmlElement = xmlResponseDocument.CreateElement(Engine.Consts.STRXML_RspErrorMessage);
xmlElement.InnerText = errorMessage;
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
}
strXmlResponse = xmlResponseDocument.InnerXml;
}
catch (ArgumentException)
{
//
// Unknown command so pass to base class to process
//
strXmlResponse = base.ExecuteXmlRequest(xmlRequest);
}
catch (Exception ex)
{
Logfile.Write(ex.Message);
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName);
return(strXmlResponse);
}
//-------------------------------------------------------------------------------------------------//
public override string ExecuteXmlRequest(string xmlRequest)
{
string strXmlResponse = string.Empty;
const string STRLOG_MethodName = "ExecuteXmlRequest";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
EquipmentEngine equipmentEngine = (EquipmentEngine)this.labEquipmentEngine;
try
{
bool success = true;
string errorMessage = string.Empty;
CommandInfo commandInfo = null;
CommandInfo resultInfo = null;
//
// Create the XML response
//
XmlDocument xmlResponseDocument = new XmlDocument();
XmlElement xmlElement = xmlResponseDocument.CreateElement(Engine.Consts.STRXML_Response);
xmlResponseDocument.AppendChild(xmlElement);
//
// Add success of command execution and update later
//
xmlElement = xmlResponseDocument.CreateElement(Engine.Consts.STRXML_RspSuccess);
xmlElement.InnerText = success.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
//
// Parse XML request for the command
//
XmlDocument xmlRequestDocument = new XmlDocument();
xmlRequestDocument.LoadXml(xmlRequest);
XmlNode xmlRequestNode = XmlUtilities.GetXmlRootNode(xmlRequestDocument, Engine.Consts.STRXML_Request);
string strCommand = XmlUtilities.GetXmlValue(xmlRequestNode, Engine.Consts.STRXML_Command, false);
NonExecuteCommands nonExecuteCommand = (NonExecuteCommands)(-1);
ExecuteCommands executeCommand = (ExecuteCommands)(-1);
try
{
//
// Try to convert to a non-execute command type that doesn't require powerdown to be suspended
//
nonExecuteCommand = (NonExecuteCommands)Enum.Parse(typeof(NonExecuteCommands), strCommand);
Logfile.Write(STRLOG_Command + nonExecuteCommand.ToString());
}
catch
{
try
{
//
// Try to convert to an execute command type that does require powerdown to be suspended
//
executeCommand = (ExecuteCommands)Enum.Parse(typeof(ExecuteCommands), strCommand);
Logfile.Write(STRLOG_Command + executeCommand.ToString());
//
// Check that powerdown has been suspended before executing the command
//
if (this.labEquipmentEngine.IsPowerdownSuspended == false)
{
//
// Suspend the powerdown before executing the command
//
this.labEquipmentEngine.SuspendPowerdown();
}
}
catch
{
//
// Unknown command
//
success = false;
errorMessage = STRERR_UnknownCommand + strCommand;
}
}
if (success == true && nonExecuteCommand != (NonExecuteCommands)(-1))
{
//
// Process the non-execute command
//
switch (nonExecuteCommand)
{
case NonExecuteCommands.GetTubeHomeDistance:
//
// Get tube home distance
//
int tubeHomeDistance = equipmentEngine.GetTubeHomeDistance();
//
// Add tube home distance to response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspTubeHomeDistance);
xmlElement.InnerText = tubeHomeDistance.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetTubeMoveTime:
//
// Get distance 'from' and 'to' from request
//
int distanceFrom = XmlUtilities.GetIntValue(xmlRequestNode, Consts.STRXML_ReqTubeDistanceFrom, 0);
int distanceTo = XmlUtilities.GetIntValue(xmlRequestNode, Consts.STRXML_ReqTubeDistanceTo, 0);
//
// Get tube move time
//
double tubeMoveTime = equipmentEngine.GetTubeMoveTime(distanceFrom, distanceTo);
//
// Add tube move time to response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspTubeMoveTime);
xmlElement.InnerText = tubeMoveTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetSourceHomeLocation:
//
// Get source home location
//
char sourceHomeLocation = equipmentEngine.GetSourceHomeLocation();
//
// Add source home location to response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspSourceHomeLocation);
xmlElement.InnerText = sourceHomeLocation.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetSourceSelectTime:
//
// Get source location from request
//
char sourceLocation = XmlUtilities.GetCharValue(xmlRequestNode, Consts.STRXML_ReqSourceLocation, Char.MinValue);
//
// Get source select time
//
double sourceSelectTime = equipmentEngine.GetSourceSelectTime(sourceLocation);
//
// Add source select time to response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspSourceSelectTime);
xmlElement.InnerText = sourceSelectTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetSourceReturnTime:
//
// Get source location from request
//
sourceLocation = XmlUtilities.GetCharValue(xmlRequestNode, Consts.STRXML_ReqSourceLocation, Char.MinValue);
//
// Get source return time
//
double sourceReturnTime = equipmentEngine.GetSourceReturnTime(sourceLocation);
//
// Add source return time to response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspSourceReturnTime);
xmlElement.InnerText = sourceReturnTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetAbsorberHomeLocation:
//
// Get absorber home location
//
char absorberHomeLocation = equipmentEngine.GetAbsorberHomeLocation();
//
// Add absorber home location to response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspAbsorberHomeLocation);
xmlElement.InnerText = absorberHomeLocation.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetAbsorberSelectTime:
//
// Get absorber location from request
//
char absorberLocation = XmlUtilities.GetCharValue(xmlRequestNode, Consts.STRXML_ReqAbsorberLocation, Char.MinValue);
//
// Get absorber select time
//
double absorberSelectTime = equipmentEngine.GetAbsorberSelectTime(absorberLocation);
//
// Add absorber select time to response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspAbsorberSelectTime);
xmlElement.InnerText = absorberSelectTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetAbsorberReturnTime:
//
// Get absorber location from request
//
absorberLocation = XmlUtilities.GetCharValue(xmlRequestNode, Consts.STRXML_ReqAbsorberLocation, Char.MinValue);
//
// Get absorber return time
//
double absorberReturnTime = equipmentEngine.GetAbsorberReturnTime(absorberLocation);
//
// Add absorber return time to response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspAbsorberReturnTime);
xmlElement.InnerText = absorberReturnTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetLcdWriteLineTime:
//
// Get LCD writeline time
//
double lcdWriteLineTime = equipmentEngine.GetLcdWriteLineTime();
//
// Add capture data time to response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspLcdWriteLineTime);
xmlElement.InnerText = lcdWriteLineTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetCaptureDataTime:
//
// Get duration from request
//
int duration = XmlUtilities.GetIntValue(xmlRequestNode, Consts.STRXML_ReqDuration, 0);
//
// Get capture data time
//
double captureDataTime = equipmentEngine.GetCaptureDataTime(duration);
//
// Add capture data time to response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspCaptureDataTime);
xmlElement.InnerText = captureDataTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
}
}
else if (success == true && executeCommand != (ExecuteCommands)(-1))
{
//
// Only one execute command allowed at a time
//
lock (this.managerLock)
{
//
// Create an instance of the command info ready to fill in
//
commandInfo = new CommandInfo(executeCommand);
//
// Process the execute command
//
switch (executeCommand)
{
case ExecuteCommands.SetTubeDistance:
//
// Get tube distance from request
//
int tubeDistance = XmlUtilities.GetIntValue(xmlRequestNode, Consts.STRXML_ReqTubeDistance, 0);
//
// Set tube distance
//
commandInfo.parameters = new object[] { tubeDistance };
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.SetSourceLocation:
//
// Get source location from request
//
char sourceLocation = XmlUtilities.GetCharValue(xmlRequestNode, Consts.STRXML_ReqSourceLocation, Char.MinValue);
//
// Set source location
//
commandInfo.parameters = new object[] { sourceLocation };
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.SetAbsorberLocation:
//
// Get absorber location from request
//
char absorberLocation = XmlUtilities.GetCharValue(xmlRequestNode, Consts.STRXML_ReqAbsorberLocation, Char.MinValue);
//
// Set absorber location
//
commandInfo.parameters = new object[] { absorberLocation };
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.GetCaptureData:
//
// Get duration from request
//
int duration = XmlUtilities.GetIntValue(xmlRequestNode, Consts.STRXML_ReqDuration, 0);
//
// Get radiation count
//
int count = -1;
commandInfo.parameters = new object[] { duration };
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
if (commandInfo.success == true)
{
count = (int)commandInfo.results[0];
}
//
// Add radiation count to response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspCount);
xmlElement.InnerText = count.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case ExecuteCommands.WriteLcdLine:
//
// Get LCD line number and message from request
//
int lcdLineNo = XmlUtilities.GetIntValue(xmlRequestNode, Consts.STRXML_ReqLcdLineNo, 0);
string lcdMessage = XmlUtilities.GetXmlValue(xmlRequestNode, Consts.STRXML_ReqLcdMessage, false);
//
// Write message to LCD
//
commandInfo.parameters = new object[] { lcdLineNo, lcdMessage };
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
}
success = resultInfo.success;
errorMessage = resultInfo.errorMessage;
}
}
//
// Update success of command execution
//
XmlNode xmlResponseNode = XmlUtilities.GetXmlRootNode(xmlResponseDocument, Engine.Consts.STRXML_Response);
XmlUtilities.SetXmlValue(xmlResponseNode, Engine.Consts.STRXML_RspSuccess, success.ToString(), false);
if (success == false)
{
//
// Create error response
//
xmlElement = xmlResponseDocument.CreateElement(Engine.Consts.STRXML_RspErrorMessage);
xmlElement.InnerText = errorMessage;
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
}
strXmlResponse = xmlResponseDocument.InnerXml;
}
catch (ArgumentException)
{
//
// Unknown command so pass to base class to process
//
strXmlResponse = base.ExecuteXmlRequest(xmlRequest);
}
catch (Exception ex)
{
Logfile.Write(ex.Message);
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName);
return(strXmlResponse);
}
//-------------------------------------------------------------------------------------------------//
public virtual string ExecuteXmlRequest(string xmlRequest)
{
string strXmlResponse = string.Empty;
const string STRLOG_MethodName = "ExecuteXmlRequest";
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
try
{
bool success = true;
string errorMessage = string.Empty;
ExecuteCommandInfo executeCommandInfo = null;
ExecuteCommandInfo executeResultInfo = null;
//
// Create the XML response
//
XmlDocument xmlResponseDocument = new XmlDocument();
XmlElement xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_Response);
xmlResponseDocument.AppendChild(xmlElement);
//
// Add success of command execution and update later
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspSuccess);
xmlElement.InnerText = success.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
//
// Parse XML request for the command
//
XmlDocument xmlRequestDocument = new XmlDocument();
xmlRequestDocument.LoadXml(xmlRequest);
XmlNode xmlRequestNode = XmlUtilities.GetXmlRootNode(xmlRequestDocument, Consts.STRXML_Request);
string strCommand = XmlUtilities.GetXmlValue(xmlRequestNode, Consts.STRXML_Command, false);
NonExecuteCommands nonExecuteCommand = (NonExecuteCommands)(-1);
ExecuteCommands executeCommand = (ExecuteCommands)(-1);
try
{
//
// Try to convert to a non-execute command type that doesn't require powerdown to be suspended
//
nonExecuteCommand = (NonExecuteCommands)Enum.Parse(typeof(NonExecuteCommands), strCommand);
Logfile.Write(STRLOG_Command + nonExecuteCommand.ToString());
}
catch
{
try
{
//
// Try to convert to an execute command type that does require powerdown to be suspended
//
executeCommand = (ExecuteCommands)Enum.Parse(typeof(ExecuteCommands), strCommand);
Logfile.Write(STRLOG_Command + executeCommand.ToString());
//
// Check that powerdown has been suspended before executing the command
//
if (this.labEquipmentEngine.IsPowerdownSuspended == false)
{
//
// Unable to execute the command
//
success = false;
errorMessage = STRERR_PowerdownMustBeSuspended + executeCommand.ToString();
}
}
catch
{
//
// Unknown command
//
success = false;
errorMessage = STRERR_UnknownCommand + strCommand;
}
}
if (success == true && nonExecuteCommand != (NonExecuteCommands)(-1))
{
//
// Process the non-execute command
//
switch (nonExecuteCommand)
{
case NonExecuteCommands.GetTime:
//
// Add time to response
//
xmlElement = xmlResponseDocument.CreateElement("Time");
xmlElement.InnerText = DateTime.Now.ToShortTimeString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
}
}
else if (success == true && executeCommand != (ExecuteCommands)(-1))
{
//
// Only one execute command allowed at a time
//
lock (this.managerLock)
{
//
// Create an instance of the command info ready to fill in
//
executeCommandInfo = new ExecuteCommandInfo(executeCommand);
//
// Process the execute command
//
switch (executeCommand)
{
case ExecuteCommands.SetTime:
//
// Pretend to change the time
//
executeCommandInfo.parameters = new object[] { DateTime.Now };
executeCommandInfo.timeout = 20;
executeResultInfo = this.labEquipmentEngine.ExecuteCommand(executeCommandInfo);
if (executeResultInfo.success == true)
{
DateTime dateTime = (DateTime)executeCommandInfo.results[0];
}
break;
}
}
}
//
// Update success of command execution
//
XmlNode xmlResponseNode = XmlUtilities.GetXmlRootNode(xmlResponseDocument, Engine.Consts.STRXML_Response);
XmlUtilities.SetXmlValue(xmlResponseNode, Engine.Consts.STRXML_RspSuccess, executeResultInfo.success.ToString(), false);
if (success == false)
{
//
// Create error response
//
xmlElement = xmlResponseDocument.CreateElement(Engine.Consts.STRXML_RspErrorMessage);
xmlElement.InnerText = executeResultInfo.errorMessage;
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
}
strXmlResponse = xmlResponseDocument.InnerXml;
}
catch (Exception ex)
{
Logfile.Write(ex.Message);
}
Logfile.WriteCompleted(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
return(strXmlResponse);
}
//-------------------------------------------------------------------------------------------------//
public override string ExecuteXmlRequest(string xmlRequest)
{
string strXmlResponse = string.Empty;
const string STRLOG_MethodName = "ExecuteXmlRequest";
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
EquipmentEngine equipmentEngine = (EquipmentEngine)this.labEquipmentEngine;
try
{
bool success = true;
string errorMessage = string.Empty;
CommandInfo commandInfo = null;
CommandInfo resultInfo = null;
//
// Create the XML response
//
XmlDocument xmlResponseDocument = new XmlDocument();
XmlElement xmlElement = xmlResponseDocument.CreateElement(Engine.Consts.STRXML_Response);
xmlResponseDocument.AppendChild(xmlElement);
//
// Add success of command execution and update later
//
xmlElement = xmlResponseDocument.CreateElement(Engine.Consts.STRXML_RspSuccess);
xmlElement.InnerText = success.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
//
// Parse XML request for the command
//
XmlDocument xmlRequestDocument = new XmlDocument();
xmlRequestDocument.LoadXml(xmlRequest);
XmlNode xmlRequestNode = XmlUtilities.GetXmlRootNode(xmlRequestDocument, Engine.Consts.STRXML_Request);
string strCommand = XmlUtilities.GetXmlValue(xmlRequestNode, Engine.Consts.STRXML_Command, false);
NonExecuteCommands nonExecuteCommand = (NonExecuteCommands)(-1);
ExecuteCommands executeCommand = (ExecuteCommands)(-1);
try
{
//
// Try to convert to a non-execute command type that doesn't require powerdown to be suspended
//
nonExecuteCommand = (NonExecuteCommands)Enum.Parse(typeof(NonExecuteCommands), strCommand);
Logfile.Write(this.logLevel, STRLOG_Command + nonExecuteCommand.ToString());
}
catch
{
try
{
//
// Try to convert to an execute command type that does require powerdown to be suspended
//
executeCommand = (ExecuteCommands)Enum.Parse(typeof(ExecuteCommands), strCommand);
Logfile.Write(this.logLevel, STRLOG_Command + executeCommand.ToString());
//
// Check that powerdown has been suspended before executing the command
//
if (this.labEquipmentEngine.IsPowerdownSuspended == false)
{
//
// Suspend the powerdown before executing the command
//
this.labEquipmentEngine.SuspendPowerdown();
}
}
catch
{
//
// Unknown command
//
success = false;
errorMessage = STRERR_UnknownCommand + strCommand;
}
}
if (success == true && nonExecuteCommand != (NonExecuteCommands)(-1))
{
//
// Process the non-execute command
//
switch (nonExecuteCommand)
{
case NonExecuteCommands.GetResetACDriveTime:
//
// Get the time to reset the AC drive
//
int resetACDriveTime = equipmentEngine.GetResetACDriveTime();
//
// Add the time to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspResetACDriveTime);
xmlElement.InnerText = resetACDriveTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetConfigureACDriveTime:
//
// Get the time to configure the AC drive
//
int configureACDriveTime = equipmentEngine.GetConfigureACDriveTime();
//
// Add the time to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspConfigureACDriveTime);
xmlElement.InnerText = configureACDriveTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetStartACDriveTime:
//
// Get the time to start the AC drive
//
int startACDriveTime = equipmentEngine.GetStartACDriveTime();
//
// Add the time to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspStartACDriveTime);
xmlElement.InnerText = startACDriveTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetStopACDriveTime:
//
// Get the time to stop the AC drive
//
int stopACDriveTime = equipmentEngine.GetStopACDriveTime();
//
// Add the time to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspStopACDriveTime);
xmlElement.InnerText = stopACDriveTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetResetDCDriveMutTime:
//
// Get the time to reset the DC drive
//
int resetDCDriveMutTime = equipmentEngine.GetResetDCDriveMutTime();
//
// Add the time to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspResetDCDriveMutTime);
xmlElement.InnerText = resetDCDriveMutTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetConfigureDCDriveMutTime:
//
// Get the time to configure the DC drive
//
int configureDCDriveMutTime = equipmentEngine.GetConfigureDCDriveMutTime();
//
// Add the time to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspConfigureDCDriveMutTime);
xmlElement.InnerText = configureDCDriveMutTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetStartDCDriveMutTime:
//
// Get DC drive mode from request
//
string strDCDriveMutMode = XmlUtilities.GetXmlValue(xmlRequestNode, Consts.STRXML_ReqDCDriveMutMode, false);
RedLion.DCDriveMutModes dcDriveMutMode = (RedLion.DCDriveMutModes)Enum.Parse(typeof(RedLion.DCDriveMutModes), strDCDriveMutMode);
//
// Get the time to start the DC drive for the specified mode
//
int startDCDriveMutTime = equipmentEngine.GetStartDCDriveMutTime(dcDriveMutMode);
//
// Add the time to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspStartDCDriveMutTime);
xmlElement.InnerText = startDCDriveMutTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetStopDCDriveMutTime:
//
// Get the time to stop the DC drive
//
int stopDCDriveMutTime = equipmentEngine.GetStopDCDriveMutTime();
//
// Add the time to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspStopDCDriveMutTime);
xmlElement.InnerText = stopDCDriveMutTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetSetSpeedACDriveTime:
//
// Get the time to set the speed of the AC drive
//
int setSpeedACDriveTime = equipmentEngine.GetSetSpeedACDriveTime();
//
// Add the time to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspSetSpeedACDriveTime);
xmlElement.InnerText = setSpeedACDriveTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetSetSpeedDCDriveMutTime:
//
// Get the time to set the speed of the DC drive
//
int setSpeedDCDriveMutTime = equipmentEngine.GetSetSpeedDCDriveMutTime();
//
// Add the time to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspSetSpeedDCDriveMutTime);
xmlElement.InnerText = setSpeedDCDriveMutTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetSetTorqueDCDriveMutTime:
//
// Get the time to set the torque of the DC drive
//
int setTorqueDCDriveMutTime = equipmentEngine.GetSetTorqueDCDriveMutTime();
//
// Add the time to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspSetTorqueDCDriveMutTime);
xmlElement.InnerText = setTorqueDCDriveMutTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetSetFieldDCDriveMutTime:
//
// Get the time to set the field of the DC drive
//
int setFieldDCDriveMutTime = equipmentEngine.GetSetFieldDCDriveMutTime();
//
// Add the time to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspSetFieldDCDriveMutTime);
xmlElement.InnerText = setFieldDCDriveMutTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetTakeMeasurementTime:
//
// Get the time to take a measurement
//
int takeMeasurementTime = equipmentEngine.GetTakeMeasurementTime();
//
// Add the time to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspTakeMeasurementTime);
xmlElement.InnerText = takeMeasurementTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetACDriveInfo:
//
// Get the info about the AC drive
//
RedLion.ACDriveInfo aCDriveInfo = equipmentEngine.GetACDriveInfo();
//
// Add the info to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspMinSpeed);
xmlElement.InnerText = aCDriveInfo.minSpeed.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspMaxSpeed);
xmlElement.InnerText = aCDriveInfo.maxSpeed.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetDCDriveMutInfo:
//
// Get the info about the AC drive
//
RedLion.DCDriveMutInfo dCDriveMutInfo = equipmentEngine.GetDCDriveMutInfo();
//
// Add the info to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspMinSpeed);
xmlElement.InnerText = dCDriveMutInfo.minSpeed.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspMaxSpeed);
xmlElement.InnerText = dCDriveMutInfo.maxSpeed.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspDefaultField);
xmlElement.InnerText = dCDriveMutInfo.defaultField.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspDefaultTorque);
xmlElement.InnerText = dCDriveMutInfo.defaultTorque.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
}
}
else if (success == true && executeCommand != (ExecuteCommands)(-1))
{
//
// Only one execute command allowed at a time
//
lock (this.managerLock)
{
//
// Create an instance of the command info ready to fill in
//
commandInfo = new CommandInfo(executeCommand);
//
// Process the execute command
//
switch (executeCommand)
{
case ExecuteCommands.CreateConnection:
//
// Create a connection to the RedLion controller
//
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.CloseConnection:
//
// Close the connection to the RedLion controller
//
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.ResetACDrive:
//
// Reset the AC drive controller
//
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.ConfigureACDrive:
//
// Get AC drive configuration from request
//
string strACDriveConfig = XmlUtilities.GetXmlValue(xmlRequestNode, Consts.STRXML_ReqACDriveConfig, false);
RedLion.ACDriveConfigs aCDriveConfig = (RedLion.ACDriveConfigs)Enum.Parse(typeof(RedLion.ACDriveConfigs), strACDriveConfig);
//
// Configure the AC drive with the specified configuration
//
commandInfo.parameters = new object[] { aCDriveConfig };
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.StartACDrive:
//
// Start the AC drive
//
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.StopACDrive:
//
// Stop the AC drive
//
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.ResetDCDriveMut:
//
// Reset the DC drive
//
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.ConfigureDCDriveMut:
//
// Get DC drive configuration from request
//
string strDCDriveMutConfig = XmlUtilities.GetXmlValue(xmlRequestNode, Consts.STRXML_ReqDCDriveMutConfig, false);
RedLion.DCDriveMutConfigs dcDriveMutConfig = (RedLion.DCDriveMutConfigs)Enum.Parse(typeof(RedLion.DCDriveMutConfigs), strDCDriveMutConfig);
//
// Configure the AC drive with the specified configuration
//
commandInfo.parameters = new object[] { dcDriveMutConfig };
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.StartDCDriveMut:
//
// Get DC drive mode from request
//
string strDCDriveMutMode = XmlUtilities.GetXmlValue(xmlRequestNode, Consts.STRXML_ReqDCDriveMutMode, false);
RedLion.DCDriveMutModes dcDriveMutMode = (RedLion.DCDriveMutModes)Enum.Parse(typeof(RedLion.DCDriveMutModes), strDCDriveMutMode);
//
// Start the DC drive
//
commandInfo.parameters = new object[] { dcDriveMutMode };
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.StopDCDriveMut:
//
// Stop the DC drive
//
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.SetSpeedACDrive:
//
// Get speed from request
//
int speedACDrive = XmlUtilities.GetIntValue(xmlRequestNode, Consts.STRXML_ReqSpeedACDrive, 0);
//
// Set the speed of the AC drive
//
commandInfo.parameters = new object[] { speedACDrive };
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.SetSpeedDCDriveMut:
//
// Get speed from request
//
int speedDCDriveMut = XmlUtilities.GetIntValue(xmlRequestNode, Consts.STRXML_ReqSpeedDCDriveMut, 0);
//
// Set the speed of the DC drive
//
commandInfo.parameters = new object[] { speedDCDriveMut };
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.SetTorqueDCDriveMut:
//
// Get torque from request
//
int torqueDCDriveMut = XmlUtilities.GetIntValue(xmlRequestNode, Consts.STRXML_ReqTorqueDCDriveMut, 0);
//
// Set the torque of the DC drive
//
commandInfo.parameters = new object[] { torqueDCDriveMut };
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.SetFieldDCDriveMut:
//
// Get torque from request
//
int fieldDCDriveMut = XmlUtilities.GetIntValue(xmlRequestNode, Consts.STRXML_ReqFieldDCDriveMut, 100);
//
// Set the field of the DC drive
//
commandInfo.parameters = new object[] { fieldDCDriveMut };
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
case ExecuteCommands.TakeMeasurement:
//
// Take a measurement
//
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
if (commandInfo.success == true)
{
//
// Get measurement values from the result
//
int speed = (int)commandInfo.results[0];
int voltage = (int)commandInfo.results[1];
float fieldCurrent = (float)commandInfo.results[2];
int load = (int)commandInfo.results[3];
//
// Add the measurement values to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspSpeed);
xmlElement.InnerText = speed.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspVoltage);
xmlElement.InnerText = voltage.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspFieldCurrent);
xmlElement.InnerText = fieldCurrent.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspLoad);
xmlElement.InnerText = load.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
}
break;
}
success = resultInfo.success;
errorMessage = resultInfo.errorMessage;
}
}
//
// Update success of command execution
//
XmlNode xmlResponseNode = XmlUtilities.GetXmlRootNode(xmlResponseDocument, Engine.Consts.STRXML_Response);
XmlUtilities.SetXmlValue(xmlResponseNode, Engine.Consts.STRXML_RspSuccess, success.ToString(), false);
if (success == false)
{
//
// Create error response
//
xmlElement = xmlResponseDocument.CreateElement(Engine.Consts.STRXML_RspErrorMessage);
xmlElement.InnerText = errorMessage;
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
}
strXmlResponse = xmlResponseDocument.InnerXml;
}
catch (ArgumentException)
{
//
// Unknown command so pass to base class to process
//
strXmlResponse = base.ExecuteXmlRequest(xmlRequest);
}
catch (Exception ex)
{
Logfile.Write(ex.Message);
}
Logfile.WriteCompleted(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
return(strXmlResponse);
}
//-------------------------------------------------------------------------------------------------//
public override string ExecuteXmlRequest(string xmlRequest)
{
string strXmlResponse = string.Empty;
const string STRLOG_MethodName = "ExecuteXmlRequest";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
EquipmentEngine equipmentEngine = (EquipmentEngine)this.labEquipmentEngine;
try
{
bool success = true;
string errorMessage = string.Empty;
CommandInfo commandInfo = null;
CommandInfo resultInfo = null;
//
// Create the XML response
//
XmlDocument xmlResponseDocument = new XmlDocument();
XmlElement xmlElement = xmlResponseDocument.CreateElement(Engine.Consts.STRXML_Response);
xmlResponseDocument.AppendChild(xmlElement);
//
// Add success of command execution and update later
//
xmlElement = xmlResponseDocument.CreateElement(Engine.Consts.STRXML_RspSuccess);
xmlElement.InnerText = success.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
//
// Parse XML request for the command
//
XmlDocument xmlRequestDocument = new XmlDocument();
xmlRequestDocument.LoadXml(xmlRequest);
XmlNode xmlRequestNode = XmlUtilities.GetXmlRootNode(xmlRequestDocument, Engine.Consts.STRXML_Request);
string strCommand = XmlUtilities.GetXmlValue(xmlRequestNode, Engine.Consts.STRXML_Command, false);
NonExecuteCommands nonExecuteCommand = (NonExecuteCommands)(-1);
ExecuteCommands executeCommand = (ExecuteCommands)(-1);
try
{
//
// Try to convert to a non-execute command type that doesn't require powerdown to be suspended
//
nonExecuteCommand = (NonExecuteCommands)Enum.Parse(typeof(NonExecuteCommands), strCommand);
Logfile.Write(STRLOG_Command + nonExecuteCommand.ToString());
}
catch
{
try
{
//
// Try to convert to an execute command type that does require powerdown to be suspended
//
executeCommand = (ExecuteCommands)Enum.Parse(typeof(ExecuteCommands), strCommand);
Logfile.Write(STRLOG_Command + executeCommand.ToString());
//
// Check that powerdown has been suspended before executing the command
//
if (this.labEquipmentEngine.IsPowerdownSuspended == false)
{
//
// Suspend the powerdown before executing the command
//
this.labEquipmentEngine.SuspendPowerdown();
}
}
catch
{
//
// Unknown command
//
success = false;
errorMessage = STRERR_UnknownCommand + strCommand;
}
}
if (success == true && nonExecuteCommand != (NonExecuteCommands)(-1))
{
//
// Process the non-execute command
//
switch (nonExecuteCommand)
{
case NonExecuteCommands.GetExecutionTime:
//
// Get specification in XML format from request
//
string xmlSpecification = XmlUtilities.GetXmlValue(xmlRequestNode, Consts.STRXML_ReqSpecification, false);
//
// Get the time to execute the specified setup
//
int executionTime = equipmentEngine.GetExecutionTime(xmlSpecification);
//
// Add the time to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspExecutionTime);
xmlElement.InnerText = executionTime.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetExecutionStatus:
//
// Get the execution status
//
DriverMachine.ExecutionStatus executionStatus = equipmentEngine.GetExecutionStatus();
//
// Add the execution status to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspExecutionStatus);
xmlElement.InnerText = executionStatus.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
//
// Get the execution time remaining
//
int executionTimeRemaining = equipmentEngine.GetExecutionTimeRemaining();
//
// Add the execution status to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspExecutionTimeRemaining);
xmlElement.InnerText = executionTimeRemaining.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetExecutionResultStatus:
//
// Get the execution result status
//
DriverMachine.ExecutionStatus executionResultStatus = equipmentEngine.GetExecutionResultStatus();
//
// Add the execution result status to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspExecutionResultStatus);
xmlElement.InnerText = executionResultStatus.ToString();
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
case NonExecuteCommands.GetExecutionResults:
//
// Get the execution results
//
string executionResults = equipmentEngine.GetExecutionResults();
//
// Add the execution status to the response
//
xmlElement = xmlResponseDocument.CreateElement(Consts.STRXML_RspExecutionResults);
xmlElement.InnerXml = executionResults;
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
break;
}
}
else if (success == true && executeCommand != (ExecuteCommands)(-1))
{
//
// Only one execute command allowed at a time
//
lock (this.managerLock)
{
//
// Create an instance of the command info ready to fill in
//
commandInfo = new CommandInfo(executeCommand);
//
// Process the execute command
//
switch (executeCommand)
{
case ExecuteCommands.StartExecution:
//
// Get specification in XML format from request
//
string xmlSpecification = XmlUtilities.GetXmlValue(xmlRequestNode, Consts.STRXML_ReqSpecification, false);
//
// Start execution with the given specification
//
commandInfo.parameters = new object[] { xmlSpecification };
resultInfo = (CommandInfo)equipmentEngine.ExecuteCommand((ExecuteCommandInfo)commandInfo);
break;
}
success = resultInfo.success;
errorMessage = resultInfo.errorMessage;
}
}
//
// Update success of command execution
//
XmlNode xmlResponseNode = XmlUtilities.GetXmlRootNode(xmlResponseDocument, Engine.Consts.STRXML_Response);
XmlUtilities.SetXmlValue(xmlResponseNode, Engine.Consts.STRXML_RspSuccess, success.ToString(), false);
if (success == false)
{
//
// Create error response
//
xmlElement = xmlResponseDocument.CreateElement(Engine.Consts.STRXML_RspErrorMessage);
xmlElement.InnerText = errorMessage;
xmlResponseDocument.DocumentElement.AppendChild(xmlElement);
}
strXmlResponse = xmlResponseDocument.InnerXml;
}
catch (ArgumentException)
{
//
// Unknown command so pass to base class to process
//
strXmlResponse = base.ExecuteXmlRequest(xmlRequest);
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName);
return(strXmlResponse);
}