//-------------------------------------------------------------------------------------------------//
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 ExecuteCommandInfo ProcessCommand(ExecuteCommandInfo executeCommandInfo)
{
const string STRLOG_MethodName = "ProcessCommand";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
CommandInfo commandInfo = (CommandInfo)executeCommandInfo;
bool success = true;
string errorMessage = null;
try
{
//
// Process the execute command
//
ExecuteCommands executeCommand = (ExecuteCommands)commandInfo.command;
switch (executeCommand)
{
//
// YOUR CODE HERE
//
case ExecuteCommands.DoSomething:
// Remove this command in your implementation
break;
default:
//
// Unknown command
//
errorMessage = STRERR_UnknownCommand + executeCommand.ToString();
success = false;
break;
}
}
catch (Exception ex)
{
success = false;
errorMessage = ex.Message;
}
//
// Update success of command execution
//
executeCommandInfo.success = success;
string logMessage = STRLOG_Success + success.ToString();
if (success == false)
{
executeCommandInfo.errorMessage = errorMessage;
logMessage += Logfile.STRLOG_Spacer + STRLOG_ErrorMessage + errorMessage;
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return executeCommandInfo;
}
//-------------------------------------------------------------------------------------------------//
public override ExecuteCommandInfo ProcessCommand(ExecuteCommandInfo executeCommandInfo)
{
const string STRLOG_MethodName = "ProcessCommand";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
CommandInfo commandInfo = (CommandInfo)executeCommandInfo;
bool success = false;
string errorMessage = null;
try
{
//
// Process the execute command
//
ExecuteCommands executeCommand = (ExecuteCommands)commandInfo.command;
switch (executeCommand)
{
case ExecuteCommands.StartExecution:
//
// Get the specification in XML format from the parameters and parse
//
string xmlSpecification = (string)commandInfo.parameters[0];
Specification specification = new Specification(this.xmlNodeEquipmentConfig);
ValidationReport validationReport = specification.Parse(xmlSpecification);
if (validationReport.accepted == false)
{
errorMessage = validationReport.errorMessage;
break;
}
//
// Create an instance of the driver for the specified setup
// and then start the driver with the specification
//
if (specification.SetupId.Equals(Consts.STRXML_SetupId_OpenCircuitVaryField) == true)
{
this.driverMachine = new DriverMachine_OCVF(this.xmlNodeEquipmentConfig, specification);
}
else if (specification.SetupId.Equals(Consts.STRXML_SetupId_OpenCircuitVarySpeed) == true)
{
this.driverMachine = new DriverMachine_OCVS(this.xmlNodeEquipmentConfig, specification);
}
else if (specification.SetupId.Equals(Consts.STRXML_SetupId_ShortCircuitVaryField) == true)
{
this.driverMachine = new DriverMachine_SCVF(this.xmlNodeEquipmentConfig, specification);
}
else if (specification.SetupId.Equals(Consts.STRXML_SetupId_PreSynchronisation) == true)
{
this.driverMachine = new DriverMachine_PreSync(this.xmlNodeEquipmentConfig, specification);
}
else if (specification.SetupId.Equals(Consts.STRXML_SetupId_Synchronisation) == true)
{
this.driverMachine = new DriverMachine_Sync(this.xmlNodeEquipmentConfig, specification);
}
else
{
//
// Unknown SetupId
//
throw new Exception(STRERR_UnknownSetupId + specification.SetupId);
}
//
// Start execution of the specified setup
//
if ((success = this.driverMachine.Start()) == false)
{
errorMessage = this.driverMachine.LastError;
}
break;
default:
//
// Unknown command
//
throw new Exception(STRERR_UnknownCommand + executeCommand.ToString());
}
}
catch (Exception ex)
{
success = false;
errorMessage = ex.Message;
}
//
// Update success of command execution
//
executeCommandInfo.success = success;
string logMessage = STRLOG_Success + success.ToString();
if (success == false)
{
executeCommandInfo.errorMessage = errorMessage;
logMessage += Logfile.STRLOG_Spacer + STRLOG_ErrorMessage + errorMessage;
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return executeCommandInfo;
}
//-------------------------------------------------------------------------------------------------//
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 ExecuteCommandInfo ProcessCommand(ExecuteCommandInfo executeCommandInfo)
{
const string STRLOG_MethodName = "ProcessCommand";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
CommandInfo commandInfo = (CommandInfo)executeCommandInfo;
bool success = true;
string errorMessage = null;
try
{
//
// Process the execute command
//
ExecuteCommands executeCommand = (ExecuteCommands)commandInfo.command;
switch (executeCommand)
{
case ExecuteCommands.GetTimeOfDay:
//
// Get server URL from parameters
//
string serverUrl = (string)commandInfo.parameters[0];
//
// Get the time-of-day
//
DateTime dateTime = DateTime.MinValue;
if ((success = this.timeOfDay.GetTimeOfDay(serverUrl, ref dateTime)) == false)
{
errorMessage = this.timeOfDay.GetLastError();
}
else
{
//
// Add the measurement values to results
//
commandInfo.results = new object[] {
dateTime
};
}
break;
default:
//
// Unknown command
//
errorMessage = STRERR_UnknownCommand + executeCommand.ToString();
success = false;
break;
}
}
catch (Exception ex)
{
success = false;
errorMessage = ex.Message;
}
//
// Update success of command execution
//
executeCommandInfo.success = success;
string logMessage = STRLOG_Success + success.ToString();
if (success == false)
{
executeCommandInfo.errorMessage = errorMessage;
logMessage += Logfile.STRLOG_Spacer + STRLOG_ErrorMessage + errorMessage;
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return executeCommandInfo;
}
//-------------------------------------------------------------------------------------------------//
public override ExecuteCommandInfo ProcessCommand(ExecuteCommandInfo executeCommandInfo)
{
const string STRLOG_MethodName = "ProcessCommand";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
CommandInfo commandInfo = (CommandInfo)executeCommandInfo;
bool success = true;
string errorMessage = null;
try
{
//
// Process the execute command
//
ExecuteCommands executeCommand = (ExecuteCommands)commandInfo.command;
switch (executeCommand)
{
case ExecuteCommands.CreateConnection:
//
// Create a connection to the RedLion controller
//
if ((success = this.redLion.CreateConnection()) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.CloseConnection:
//
// Close the connection to the RedLion controller
//
if ((success = this.redLion.CloseConnection()) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.ResetACDrive:
//
// Reset the AC drive controller
//
if ((success = this.redLion.ResetACDrive()) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.ConfigureACDrive:
//
// Get AC drive configuration from parameters
//
RedLion.ACDriveConfigs acDriveConfig = (RedLion.ACDriveConfigs)commandInfo.parameters[0];
//
// Configure the AC drive
//
if ((success = this.redLion.ConfigureACDrive(acDriveConfig)) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.StartACDrive:
//
// Get AC drive mode from parameters
//
RedLion.ACDriveModes acDriveMode = (RedLion.ACDriveModes)commandInfo.parameters[0];
//
// Start the AC drive
//
if ((success = this.redLion.StartACDrive(acDriveMode)) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.StopACDrive:
//
// Get AC drive mode from parameters
//
acDriveMode = (RedLion.ACDriveModes)commandInfo.parameters[0];
//
// Stop the AC drive
//
if ((success = this.redLion.StopACDrive(acDriveMode)) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.TakeMeasurement:
//
// Take a measurement
//
RedLion.Measurements measurement = new RedLion.Measurements();
if ((success = this.redLion.TakeMeasurement(ref measurement)) == false)
{
errorMessage = this.redLion.GetLastError();
}
else
{
//
// Add the measurement values to results - ensure the order of the measurement values is the
// same as in EquipmentManager.cs
//
commandInfo.results = new object[] {
measurement.voltageMut,
measurement.currentMut,
measurement.powerFactorMut,
measurement.voltageVsd,
measurement.currentVsd,
measurement.powerFactorVsd,
measurement.speed,
measurement.torque
};
}
break;
default:
//
// Unknown command
//
errorMessage = STRERR_UnknownCommand + executeCommand.ToString();
success = false;
break;
}
}
catch (Exception ex)
{
success = false;
errorMessage = ex.Message;
}
//
// Update success of command execution
//
executeCommandInfo.success = success;
string logMessage = STRLOG_Success + success.ToString();
if (success == false)
{
executeCommandInfo.errorMessage = errorMessage;
logMessage += Logfile.STRLOG_Spacer + STRLOG_ErrorMessage + errorMessage;
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return executeCommandInfo;
}
//-------------------------------------------------------------------------------------------------//
public override ExecuteCommandInfo ProcessCommand(ExecuteCommandInfo executeCommandInfo)
{
const string STRLOG_MethodName = "ProcessCommand";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
CommandInfo commandInfo = (CommandInfo)executeCommandInfo;
bool success = true;
string errorMessage = null;
try
{
//
// Process the execute command
//
ExecuteCommands executeCommand = (ExecuteCommands)commandInfo.command;
switch (executeCommand)
{
case ExecuteCommands.SetTubeDistance:
//
// Set tube distance
//
int tubeDistance = (int)commandInfo.parameters[0];
if ((success = this.flexMotion.SetTubeDistance(tubeDistance)) == false)
{
errorMessage = this.flexMotion.GetLastError();
}
break;
case ExecuteCommands.SetSourceLocation:
//
// Set source location
//
char sourceLocation = (char)commandInfo.parameters[0];
if ((success = this.flexMotion.SetSourceLocation(sourceLocation)) == false)
{
errorMessage = this.flexMotion.GetLastError();
}
break;
case ExecuteCommands.SetAbsorberLocation:
//
// Set absorber location
//
char absorberLocation = (char)commandInfo.parameters[0];
if ((success = this.flexMotion.SetAbsorberLocation(absorberLocation)) == false)
{
errorMessage = this.flexMotion.GetLastError();
}
break;
case ExecuteCommands.GetCaptureData:
//
// Get duration from parameters
//
int duration = (int)commandInfo.parameters[0];
//
// Get radiation count
//
int count = -1;
if (this.radiationCounterType == RadiationCounterTypes.ST360)
{
int[] counts = new int[1];
if (this.st360Counter.CaptureData(duration, counts) == true)
{
count = counts[0];
}
}
else if (this.radiationCounterType == RadiationCounterTypes.Physics)
{
count = this.physicsCounter.CaptureData(duration);
}
//
// Add radiation count to results
//
commandInfo.results = new object[] { count };
break;
case ExecuteCommands.WriteLcdLine:
//
// Get LCD line number from request
//
int lcdLineNo = (int)commandInfo.parameters[0];
//
// Get LCD message from request and 'URL Decode' to preserve spaces
//
string lcdMessage = (string)commandInfo.parameters[1];
lcdMessage = HttpUtility.UrlDecode(lcdMessage);
//
// Write message to LCD
//
if ((success = this.serialLcd.WriteLine(lcdLineNo, lcdMessage)) == false)
{
errorMessage = this.serialLcd.GetLastError();
}
break;
default:
//
// Unknown command
//
errorMessage = STRERR_UnknownCommand + executeCommand.ToString();
success = false;
break;
}
}
catch (Exception ex)
{
success = false;
errorMessage = ex.Message;
}
//
// Update success of command execution
//
executeCommandInfo.success = success;
string logMessage = STRLOG_Success + success.ToString();
if (success == false)
{
executeCommandInfo.errorMessage = errorMessage;
logMessage += Logfile.STRLOG_Spacer + STRLOG_ErrorMessage + errorMessage;
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return executeCommandInfo;
}
//-------------------------------------------------------------------------------------------------//
public virtual ExecuteCommandInfo ProcessCommand(ExecuteCommandInfo executeCommandInfo)
{
const string STRLOG_MethodName = "ProcessCommand";
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
bool success = true;
string errorMessage = null;
//
// Process the execute command
//
ExecuteCommands executeCommand = (ExecuteCommands)executeCommandInfo.command;
switch (executeCommand)
{
case ExecuteCommands.SetTime:
//
// Pretending to change the time, so nothing to do here
//
DateTime dateTime = (DateTime)executeCommandInfo.parameters[0];
Logfile.Write(" parameters: dateTime -> " + dateTime.ToString());
//
// Create some dummy results
//
executeCommandInfo.results = new object[] { DateTime.Now };
dateTime = (DateTime)executeCommandInfo.results[0];
Logfile.Write(" results: dateTime -> " + dateTime.ToString());
break;
default:
//
// Unknown command
//
errorMessage = STRERR_UnknownCommand + executeCommand.ToString();
success = false;
break;
}
//
// Update success of command execution
//
executeCommandInfo.success = success;
string logMessage = STRLOG_Success + success.ToString();
if (success == false)
{
executeCommandInfo.errorMessage = errorMessage;
logMessage += Logfile.STRLOG_Spacer + STRLOG_ErrorMessage + errorMessage;
}
Logfile.WriteCompleted(this.logLevel, STRLOG_ClassName, STRLOG_MethodName, logMessage);
return executeCommandInfo;
}
//-------------------------------------------------------------------------------------------------//
public ExecuteCommandInfo ExecuteCommand(ExecuteCommandInfo executeCommandInfo)
{
const string STRLOG_MethodName = "ExecuteCommand";
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
if (this.disposed == false)
{
//
// Determine the timeout for waiting on the result
//
int timeout = executeCommandInfo.timeout;
timeout = timeout * 1000 / DELAY_MS_SignalResultCheck;
//
// Save the info and signal LabEquipmentEngine thread to execute the command
//
lock (this.signalCommand)
{
lock (this.executeCommandLock)
{
this.executeResultInfo = null;
this.executeCommandInfo = executeCommandInfo;
}
Monitor.Pulse(this.signalCommand);
}
//
// Wait for the LabEquipmentEngine thread to execute the command and return the results
//
do
{
lock (this.signalResult)
{
if (Monitor.Wait(this.signalResult, DELAY_MS_SignalResultCheck) == true)
{
Trace.WriteLine("Result received...");
}
}
lock (this.executeCommandLock)
{
if (this.executeResultInfo != null)
{
break;
}
}
}
while (--timeout > 0);
}
Logfile.WriteCompleted(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
return this.executeResultInfo;
}
//-------------------------------------------------------------------------------------------------//
private void LabEquipmentEngineThread()
{
const string STRLOG_MethodName = "LabEquipmentEngineThread";
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
//
// Initialise state machine
//
int retryPowerOnInit = RETRY_PowerOnInit;
bool retry = false;
States state = States.sPowerInit;
States lastState = States.sExitThread;
this.slOnline = true;
this.Running = true;
try
{
//
// State machine loop
//
while (this.Running == true)
{
//
// Display message on each state change
//
if (state != lastState)
{
string logMessage = " [ " + STRLOG_MethodName + ": " + lastState.ToString() + " -> " + state.ToString() + " ]";
Logfile.Write(this.logLevel, logMessage);
Trace.WriteLine(logMessage);
lastState = state;
}
switch (state)
{
case States.sPowerInit:
lock (this.statusLock)
{
this.slStatusMessage = STR_PoweringUp;
// Initialise powerup delay
this.slPowerupTimeRemaining = this.powerupDelay;
}
// Powerup the equipment
if (PowerupEquipment() == false)
{
this.slOnline = false;
this.slStatusMessage = STR_NotInitialised;
state = States.sExitThread;
break;
}
state = States.sPowerUpDelay;
break;
case States.sPowerUpDelay:
// Wait a bit
Thread.Sleep(1000);
lock (this.statusLock)
{
// Check timeout
if (--this.slPowerupTimeRemaining > 0)
{
// Equipment is still powering up
Trace.Write("u");
continue;
}
}
// Equipment is now powered up
state = States.sPowerOnInit;
break;
case States.sPowerOnInit:
// Set the power intialisation start time
lock (this.statusLock)
{
this.slStatusMessage = STR_Initialising;
this.slPowerupInitialiseStartTime = DateTime.Now;
}
//
// Initialise the equipment
//
retry = false;
if (InitialiseEquipment() == false || this.debug_Retry == true)
{
if (--retryPowerOnInit >= 0)
{
retry = true;
Logfile.WriteError(
String.Format(STRERR_InitiliaseFailedRetrying_arg2, RETRY_PowerOnInit - retryPowerOnInit, RETRY_PowerOnInit));
//
// Equipment failed to initialise, powerdown the equipment and try again
//
lock (this.statusLock)
{
this.slPowerupTimeRemaining = this.PoweroffDelay + this.PowerupDelay;
}
PowerdownEquipment();
state = States.sPowerOffDelay;
}
else
{
Logfile.WriteError(
String.Format(STRERR_InitiliaseFailedAfterRetrying_arg, RETRY_PowerOnInit + 1));
//
// Could initialise the equipment after retrying, powerdown the equipment and exit
//
this.slOnline = false;
this.slStatusMessage = STR_NotInitialised;
PowerdownEquipment();
state = States.sExitThread;
}
break;
}
lock (this.statusLock)
{
// Equipment is now ready to use
this.slStatusMessage = STR_Ready;
this.slIsReady = true;
// Initialise powerdown timeout
this.slPowerdownTimeRemaining = this.powerdownTimeout;
}
// Check if powerdown is enabled
if (this.powerdownEnabled == false)
{
this.PowerdownSuspended = true;
}
else
{
// Log the time remaining before power is removed
LogPowerDown(this.powerdownTimeout, true);
}
state = States.sPowerOnReady;
break;
case States.sPowerOnReady:
// Wait a bit
Thread.Sleep(1000);
//
// Check if equipment powerdown should be suspended
//
if (this.PowerdownSuspended == true)
{
lock (this.statusLock)
{
this.slPowerdownIsSuspended = true;
}
state = States.sPowerSuspended;
break;
}
//
// Log the time remaining before power is removed
//
int timeRemaining;
lock (this.statusLock)
{
timeRemaining = this.slPowerdownTimeRemaining;
}
LogPowerDown(timeRemaining);
lock (this.statusLock)
{
// Check timeout
if (--this.slPowerdownTimeRemaining > 0)
{
// Timeout is still counting down
Trace.Write("t");
continue;
}
//
// Equipment is powering down, determine the time before the equipment
// can be powered up again
//
this.slPowerupTimeRemaining = this.PoweroffDelay + this.PowerupDelay;
this.slIsReady = false;
this.slStatusMessage = STR_PoweringDown;
}
// Powerdown the equipment
PowerdownEquipment();
state = States.sPowerOffDelay;
break;
case States.sPowerSuspended:
//
// Check if there is a command to execute
//
lock (this.signalCommand)
{
if (Monitor.Wait(this.signalCommand, DELAY_MS_SignalCommandCheck) == true)
{
Trace.WriteLine("Command received...");
}
//
// Whether we timed out or not, check for a command
//
lock (this.executeCommandLock)
{
if (this.executeCommandInfo != null)
{
state = States.sProcessCommand;
break;
}
}
}
// Check if equipment powerdown is resumed
if (this.PowerdownSuspended == false)
{
// Log the time remaining before power is removed
LogPowerDown(this.powerdownTimeout, true);
lock (this.statusLock)
{
// Reset the powerdown timeout
this.slPowerdownTimeRemaining = this.powerdownTimeout;
this.slPowerdownIsSuspended = false;
}
state = States.sPowerOnReady;
}
break;
case States.sProcessCommand:
ExecuteCommandInfo executeResultInfo = ProcessCommand(this.executeCommandInfo);
lock (this.signalResult)
{
lock (this.executeCommandLock)
{
this.executeCommandInfo = null;
this.executeResultInfo = executeResultInfo;
}
Monitor.Pulse(this.signalResult);
}
state = States.sPowerSuspended;
break;
case States.sPowerOffDelay:
// Wait a bit
Thread.Sleep(1000);
// Check timeout
lock (this.statusLock)
{
if (--this.slPowerupTimeRemaining > this.powerupDelay)
{
// Equipment is still powering off
Trace.Write("o");
}
else
{
// Check if powerup has been requested
if (this.slPowerdownSuspended == true)
{
state = States.sPowerInit;
}
else
{
// Powerdown has completed
this.slStatusMessage = STR_PoweredDown;
//
// Check if retrying
//
if (retry == true)
{
state = States.sPowerInit;
}
else
{
state = States.sExitThread;
}
}
}
}
break;
case States.sExitThread:
//
// Thread is no longer running
//
this.Running = false;
break;
}
}
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
}
Trace.WriteLine(STRLOG_MethodName + ": Exiting");
Logfile.WriteCompleted(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
}
//-------------------------------------------------------------------------------------------------//
public override ExecuteCommandInfo ProcessCommand(ExecuteCommandInfo executeCommandInfo)
{
const string STRLOG_MethodName = "ProcessCommand";
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
CommandInfo commandInfo = (CommandInfo)executeCommandInfo;
bool success = true;
string errorMessage = null;
try
{
//
// Process the execute command
//
ExecuteCommands executeCommand = (ExecuteCommands)commandInfo.command;
switch (executeCommand)
{
case ExecuteCommands.CreateConnection:
//
// Create a connection to the RedLion controller
//
if ((success = this.redLion.CreateConnection()) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.CloseConnection:
//
// Close the connection to the RedLion controller
//
if ((success = this.redLion.CloseConnection()) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.ResetACDrive:
//
// Reset the AC drive
//
if ((success = this.redLion.ResetACDrive()) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.ConfigureACDrive:
//
// Get AC drive configuration from parameters
//
RedLion.ACDriveConfigs acCDriveConfig = (RedLion.ACDriveConfigs)commandInfo.parameters[0];
//
// Configure the AC drive with the specified configuration
//
if ((success = this.redLion.ConfigureACDrive(acCDriveConfig)) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.StartACDrive:
//
// Start the AC drive
//
if ((success = this.redLion.StartACDrive()) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.StopACDrive:
//
// Stop the AC drive
//
if ((success = this.redLion.StopACDrive()) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.ResetDCDriveMut:
//
// Reset the DC drive
//
if ((success = this.redLion.ResetDCDriveMut()) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.ConfigureDCDriveMut:
//
// Get DC drive configuration from parameters
//
RedLion.DCDriveMutConfigs dcDriveMutConfig = (RedLion.DCDriveMutConfigs)commandInfo.parameters[0];
//
// Configure the AC drive with the specified configuration
//
if ((success = this.redLion.ConfigureDCDriveMut(dcDriveMutConfig)) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.StartDCDriveMut:
//
// Get DC drive mode from parameters
//
RedLion.DCDriveMutModes dcDriveMutMode = (RedLion.DCDriveMutModes)commandInfo.parameters[0];
//
// Start the DC drive
//
if ((success = this.redLion.StartDCDriveMut(dcDriveMutMode)) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.StopDCDriveMut:
//
// Stop the DC drive
//
if ((success = this.redLion.StopDCDriveMut()) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.SetSpeedACDrive:
//
// Get speed from parameters
//
int speedACDrive = (int)commandInfo.parameters[0];
//
// Set the speed of the AC drive
//
if ((success = this.redLion.SetSpeedACDrive(speedACDrive)) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.SetSpeedDCDriveMut:
//
// Get speed from parameters
//
int speedDCDriveMut = (int)commandInfo.parameters[0];
//
// Set the speed of the DC drive
//
if ((success = this.redLion.SetSpeedDCDriveMut(speedDCDriveMut)) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.SetTorqueDCDriveMut:
//
// Get torque from parameters
//
int torqueDCDriveMut = (int)commandInfo.parameters[0];
//
// Set the torque of the DC drive
//
if ((success = this.redLion.SetTorqueDCDriveMut(torqueDCDriveMut)) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.SetFieldDCDriveMut:
//
// Get torque from parameters
//
int fieldDCDriveMut = (int)commandInfo.parameters[0];
//
// Set the field of the DC drive
//
if ((success = this.redLion.SetFieldDCDriveMut(fieldDCDriveMut)) == false)
{
errorMessage = this.redLion.GetLastError();
}
break;
case ExecuteCommands.TakeMeasurement:
//
// Take a measurement
//
RedLion.Measurements measurement = new RedLion.Measurements();
if ((success = this.redLion.TakeMeasurement(ref measurement)) == false)
{
errorMessage = this.redLion.GetLastError();
}
else
{
//
// Add the measurement values to results
//
commandInfo.results = new object[] {
measurement.speed,
measurement.voltage,
measurement.fieldCurrent,
measurement.load
};
}
break;
default:
//
// Unknown command
//
errorMessage = STRERR_UnknownCommand + executeCommand.ToString();
success = false;
break;
}
}
catch (Exception ex)
{
success = false;
errorMessage = ex.Message;
}
//
// Update success of command execution
//
executeCommandInfo.success = success;
string logMessage = STRLOG_Success + success.ToString();
if (success == false)
{
executeCommandInfo.errorMessage = errorMessage;
logMessage += Logfile.STRLOG_Spacer + STRLOG_ErrorMessage + errorMessage;
}
Logfile.WriteCompleted(this.logLevel, STRLOG_ClassName, STRLOG_MethodName, logMessage);
return executeCommandInfo;
}
