//-------------------------------------------------------------------------------------------------//
public bool GetCounts(int[] counts)
{
const string STRLOG_MethodName = "GetCounts";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
bool success = true;
try
{
//
// Write the command
//
byte[] readData = WriteReadData(new byte[] { CMD_ReadCounts }, 1, DATALEN_CMD_Read);
if (readData == null || readData.Length != DATALEN_CMD_Read || readData[0] != CMD_ReadCounts)
{
throw new Exception(STRERR_FailedToReadCounts);
}
//
// Extract count value from byte array
//
for (int i = 1; i < DATALEN_CMD_Read; i++)
{
counts[0] = counts[0] * 256 + (int)readData[i];
}
}
catch (Exception ex)
{
success = false;
this.lastError = ex.Message;
}
string logMessage = counts.ToString();
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return(success);
}
public string GetLabInfo()
{
const string STRLOG_MethodName = "GetLabInfo";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
string labInfo = null;
// Get the identity of the caller
string sbName = GetCallerName(authHeader);
// Check caller access is authorised
if (sbName != null)
{
// Pass on to experiment manager
labInfo = Global.experimentManager.GetLabInfo();
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName);
return(labInfo);
}
public List <EmployeeAttendance> GetEmployeeAttendances(DateTime date)
{
List <EmployeeAttendance> employeeAttendances = new List <EmployeeAttendance>();
try
{
DataTable dt = new DataTable();
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(@"
select distinct e.Code,e.Name, e.Dept, z.Name as DeptName, z.Manager from ZlEmployee e
left join ZlDept z on e.Dept = z.Code
left join Kq_Source s on e.ID = s.EmpID
left join Kq_PaiBan p on e.ID = p.EmpID
where (e.Dept not like '%999%' and e.Dept not like '%888%') and e.State = '0' and
e.ID in (select distinct EmpID from Kq_Source where 1=1 ");
stringBuilder.Append(" and cast(FDateTime as date) = cast( '" + date.ToString("yyyyMMdd") + "' as date ) ");
stringBuilder.Append(" and convert(char(5), FDateTime, 108) >='00:00:01' and convert(char(5), FDateTime, 108) < '23:59:59' and EmpID is not null ) ");
// stringBuilder.Append(" and p.SessionID = (select max(SessionID) from Kq_PaiBan b right join ZlEmployee a on b.EmpID = a.ID) ");
SqlHRFinger sqlHR = new SqlHRFinger();
sqlHR.sqlDataAdapterFillDatatable(stringBuilder.ToString(), ref dt);
for (int i = 0; i < dt.Rows.Count; i++)
{
employeeAttendances.Add(new EmployeeAttendance
{
Date = date.ToString("dd.MM.yyyy"),
EmpCode = dt.Rows[i]["Code"].ToString(),
EmpName = dt.Rows[i]["Name"].ToString(),
DeptCode = dt.Rows[i]["Dept"].ToString(),
Dept = dt.Rows[i]["DeptName"].ToString(),
Manager = dt.Rows[i]["Manager"].ToString()
});
}
}
catch (Exception ex)
{
Logfile.Output(StatusLog.Error, "GetEmployeeAttendances(DateTime date)", ex.Message);
}
return(employeeAttendances);
}
public string GetLabConfiguration(string userGroup)
{
const string STRLOG_MethodName = "GetLabConfiguration";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
string xmlLabConfiguration = null;
// Get the identity of the caller
string sbName = GetCallerName(authHeader);
// Check caller access is authorised
if (sbName != null)
{
// Pass on to experiment manager
xmlLabConfiguration = Global.experimentManager.GetLabConfiguration(userGroup);
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName);
return(xmlLabConfiguration);
}
//-------------------------------------------------------------------------------------------------//
public bool CloseConnection()
{
const string STRLOG_MethodName = "CloseConnection";
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
bool success = false;
this.lastError = null;
if (this.tcpClient != null)
{
try
{
NetworkStream networkStream = this.tcpClient.GetStream();
if (networkStream != null)
{
networkStream.Close();
}
this.tcpClient.Close();
this.tcpClient = null;
success = true;
}
catch (Exception ex)
{
this.lastError = ex.Message;
Logfile.WriteError(ex.Message);
}
}
this.connectionOpen = false;
string logMessage = STRLOG_Success + success.ToString();
Logfile.WriteCompleted(this.logLevel, STRLOG_ClassName, STRLOG_MethodName, logMessage);
return(success);
}
//-------------------------------------------------------------------------------------------------//
public void StopDrive()
{
const string STRLOG_MethodName = "StopDrive";
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
Trace.WriteLine(STRLOG_MethodName);
string logMessage = string.Empty;
try
{
ushort[] regs = new ushort[2] {
0x08a1, 0x1000
};
int value = (regs[1] << 16) | regs[0];
logMessage += STRLOG_Register + REGADDR_RW_AC_ControlWord.ToString();
logMessage += STRLOG_WritingHex + value.ToString("X8");
// Write to register
this.master.WriteMultipleRegisters(REGADDR_RW_AC_ControlWord, regs);
// Read back register
ushort[] inregs = this.master.ReadHoldingRegisters(REGADDR_RW_AC_ControlWord, (ushort)2);
value = (inregs[1] << 16) | inregs[0];
logMessage += STRLOG_ReadingHex + value.ToString("X8");
Logfile.Write(this.logLevel, logMessage);
Trace.WriteLine(logMessage);
WaitDelay(DELAY_StopDrive);
}
catch (Exception e)
{
Trace.WriteLine(e.Message);
throw (e);
}
}
//---------------------------------------------------------------------------------------//
protected void ReceiveData(byte[] data, int dataLength)
{
ReceiveDataInfo rdi = this.receiveDataInfo;
try
{
//
// Copy all of the data to the receive buffer
//
Array.Copy(data, 0, rdi.receiveBuffer, rdi.bufferIndex, dataLength);
rdi.bytesRead += dataLength;
rdi.bufferIndex += dataLength;
//
// Check if all of the expected data has been read
//
if (rdi.bytesRead >= rdi.expectedPacketLength)
{
//
// The buffer has at least as many bytes for this packet
//
this.responsePacket = new byte[rdi.expectedPacketLength];
Array.Copy(rdi.receiveBuffer, 0, this.responsePacket, 0, rdi.expectedPacketLength);
//
// Signal the waiting thread that the data has been received
//
lock (responseSignal)
{
Monitor.Pulse(responseSignal);
}
}
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
}
}
//-------------------------------------------------------------------------------------------------//
public bool ChangeSpeed(double speed, bool verify)
{
const string STRLOG_MethodName = "ChangeSpeed";
string logMessage = STRLOG_Speed + speed.ToString();
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName, logMessage);
bool success;
double actualSpeed = 0;
if ((success = this.SetEngValue(ModbusRegs_Holding_RW.DCControlSpeed, speed, DELAY_ChangeSpeed)) == true)
{
//
// Update speed setpoint
//
this.speedSetpoint = speed;
if (verify == true)
{
//
// Check that the speed has changed to the desired value
//
string units = String.Empty;
if ((success = this.GetSpeed(ref actualSpeed, ref units)) == true)
{
success = (actualSpeed > speed - 5 && actualSpeed < speed + 5);
}
}
}
logMessage = STRLOG_Success + success.ToString() +
Logfile.STRLOG_Spacer + STRLOG_Speed + ((int)actualSpeed).ToString();
Logfile.WriteCompleted(this.logLevel, STRLOG_ClassName, STRLOG_MethodName, logMessage);
return(success);
}
//
// YOUR CODE HERE
//
#endregion
//-------------------------------------------------------------------------------------------------//
public Specification(Configuration configuration, EquipmentService equipmentServiceProxy)
: base(configuration, equipmentServiceProxy)
{
const string STRLOG_MethodName = "Specification";
Logfile.WriteCalled(null, STRLOG_MethodName);
//
// Save these for use by the Parse() method
//
this.configuration = configuration;
//
// Check that the specification template is valid. This is used by the LabClient to submit
// the experiment specification to the LabServer for execution.
//
try
{
//
// Check that all required XML nodes exist
//
//
// YOUR CODE HERE
//
//
// Create an instance fo the Validation class
//
this.validation = new Validation(configuration);
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
throw;
}
Logfile.WriteCompleted(null, STRLOG_MethodName);
}
//-------------------------------------------------------------------------------------------------//
public bool Cancel(int experimentId, string sbName)
{
const string STRLOG_MethodName = "Cancel";
string logMessage = STRLOG_experimentId + experimentId.ToString() +
Logfile.STRLOG_Spacer + STRLOG_sbName + Logfile.STRLOG_Quote + sbName + Logfile.STRLOG_Quote +
Logfile.STRLOG_Spacer + STRLOG_unitId + unitId.ToString();
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName, logMessage);
bool success = false;
//
// Check if an experiment is currently running
//
lock (this.statusLock)
{
if (this.labExperimentInfo != null)
{
//
// An experiment is currently running, check if it is this one
//
if (this.labExperimentInfo.experimentInfo.experimentId == experimentId &&
sbName != null && sbName.Equals(this.labExperimentInfo.experimentInfo.sbName, StringComparison.OrdinalIgnoreCase))
{
// Cancel the experiment
this.labExperimentInfo.cancelExperiment.Cancel();
success = true;
}
}
}
logMessage = STRLOG_success + success.ToString();
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return(success);
}
//-------------------------------------------------------------------------------------------------//
/// <summary>
/// Dispose(bool disposing) executes in two distinct scenarios:
/// 1. If disposing equals true, the method has been called directly or indirectly by a user's code.
/// Managed and unmanaged resources can be disposed.
/// 2. If disposing equals false, the method has been called by the runtime from inside the finalizer
/// and you should not reference other objects. Only unmanaged resources can be disposed.
/// </summary>
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing)
{
const string STRLOG_MethodName = "Dispose";
string logMessage = STRLOG_disposing + disposing.ToString() +
Logfile.STRLOG_Spacer + STRLOG_disposed + this.disposed.ToString();
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName, logMessage);
//
// Check to see if Dispose has already been called
//
if (this.disposed == false)
{
//
// If disposing equals true, dispose all managed and unmanaged resources.
//
if (disposing == true)
{
// Dispose managed resources here. Anything that has a Dispose() method.
}
//
// Release unmanaged resources here. If disposing is false, only the following
// code is executed.
//
if (this.reportRunning == true)
{
this.reportRunning = false;
this.reportThread.Join();
}
this.disposed = true;
}
Logfile.WriteCompleted(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
}
//-------------------------------------------------------------------------------------------------//
public DriverMachine(XmlNode xmlNodeEquipmentConfig, Specification specification)
: base(xmlNodeEquipmentConfig, specification)
{
const string STRLOG_MethodName = "DriverMachine";
Logfile.WriteCalled(null, STRLOG_MethodName);
try
{
//
// Initialise static variables
//
if (DriverMachine.firstInstance == true)
{
DriverMachine.dcDriveInstance = new DCDrive(xmlNodeEquipmentConfig, KeepAlive);
DriverMachine.plcInstance = new PLC(xmlNodeEquipmentConfig, KeepAlive);
DriverMachine.initialiseDelay = DriverMachine.dcDriveInstance.InitialiseDelay + DriverMachine.plcInstance.InitialiseDelay;
DriverMachine.statusMessage = STRLOG_PLC + STRLOG_NotInitialised + STRLOG_DCDrive + STRLOG_NotInitialised;
DriverMachine.firstInstance = false;
}
//
// Provide access to the instances
//
this.dcDrive = dcDriveInstance;
this.plc = plcInstance;
}
catch (Exception ex)
{
//
// Log the message and throw the exception back to the caller
//
Logfile.WriteError(ex.Message);
throw;
}
Logfile.WriteCompleted(null, STRLOG_MethodName);
}
//-------------------------------------------------------------------------------------------------//
public void SetMainContactorOn()
{
const string STRLOG_MethodName = "SetMainContactorOn";
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
Trace.WriteLine(STRLOG_MethodName);
string logMessage = string.Empty;
try
{
ushort[] regs = new ushort[1] {
0x0477
};
int value = regs[0];
logMessage += STRLOG_Register + REGADDR_RW_DC_ControlWord.ToString();
logMessage += STRLOG_WritingHex + value.ToString("X4");
// Write to register
this.master.WriteMultipleRegisters(REGADDR_RW_DC_ControlWord, regs);
// Read back register
ushort[] inregs = this.master.ReadHoldingRegisters(REGADDR_RW_DC_ControlWord, (ushort)1);
value = inregs[0];
logMessage += STRLOG_ReadingHex + value.ToString("X4");
Logfile.Write(this.logLevel, logMessage);
Trace.WriteLine(logMessage);
WaitDelay(DELAY_SetMainContactorOn);
}
catch (Exception e)
{
Trace.WriteLine(e.Message);
throw (e);
}
}
//-------------------------------------------------------------------------------------------------//
public bool OpenConnection()
{
const string STRLOG_MethodName = "OpenConnection";
Logfile.WriteCalled(this.logLevel, STRLOG_ClassName, STRLOG_MethodName);
bool success = false;
this.lastError = null;
try
{
//
// Open a connection to the specified IP address and port number
//
this.tcpClient = new TcpClient(this.ipaddr, this.ipport);
success = true;
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
this.lastError = STRERR_UnableToOpenNetworkConnection + this.ipaddr + ":" + this.ipport.ToString();
}
if (success == true)
{
this.tcpClient.ReceiveTimeout = this.receiveTimeout;
this.modbusIpMaster = ModbusIpMaster.CreateTcp(tcpClient);
}
this.connectionOpen = success;
string logMessage = STRLOG_Success + success.ToString();
Logfile.WriteCompleted(this.logLevel, STRLOG_ClassName, STRLOG_MethodName, logMessage);
return(success);
}
//---------------------------------------------------------------------------------------//
private bool Authorised(AuthHeader authHeader)
{
bool ok = true;
if (Global.allowedCallers.IsAuthenticating == true)
{
//
// Check if caller is specified
//
if (authHeader == null || authHeader.identifier == null || authHeader.passKey == null)
{
// Caller is not specified
ok = false;
Logfile.Write(STRLOG_AccessDenied);
}
//
// Check if access is authorised for this caller
//
else
{
// Get the caller's name
string lsName = Global.allowedCallers.Authentication(authHeader.identifier, authHeader.passKey);
//
// Check if caller is allowed access to this web service
//
if (lsName == null)
{
// Caller is not allowed access to this Web Method
ok = false;
Logfile.Write(STRLOG_UnauthorisedAccess);
}
}
}
return(ok);
}
//-------------------------------------------------------------------------------------------------//
public ExperimentResult(Configuration configuration)
: base(configuration)
{
try
{
//
// Check that all required XML nodes exist
//
XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_sourceName, true);
XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_absorberName, true);
XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_distance, true);
XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_duration, true);
XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_repeat, true);
XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_dataType, true);
XmlUtilities.GetXmlValue(this.xmlNodeExperimentResult, Consts.STRXML_dataVector, true);
}
catch (Exception ex)
{
// Log the message and throw the exception back to the caller
Logfile.WriteError(ex.Message);
throw;
}
}
//-------------------------------------------------------------------------------------------------//
public Hardware()
{
const string STRLOG_MethodName = "Hardware";
Logfile.WriteCalled(null, STRLOG_MethodName);
//
// Initialise local variables
//
this.disposed = false;
this.initialised = false;
this.lastError = null;
//
// Initialise properties
//
this.online = false;
this.statusMessage = STRLOG_NotInitialised;
//
// YOUR CODE HERE
//
}
public bool ExportReportProductionDaiLy(PeriodProduction period)
{
try
{
DefectRateReport defectRateReport = new DefectRateReport();
List <DefectRateData> defectRateDatas = new List <DefectRateData>();
defectRateDatas = defectRateReport.GetListDefectRateReportAmountOfTimeDaily("B01", "0010", period);
if (defectRateDatas.Count == 0)
{
return(false);
}
Log.ExportExcelTool exportExcel = new Log.ExportExcelTool();
exportExcel.ExportToTemplateMQCDefectDaily(pathDaily, @"C:\ERP_Temp\MQC_Daily_Report" + "-" + DateTime.Now.ToString("yyyyMMdd hhmmss") + ".xlsx", defectRateDatas);
return(true);
}
catch (Exception ex)
{
Logfile.Output(StatusLog.Error, "ExportReportProductionDaiLy()", ex.Message);
return(false);
}
}
//-------------------------------------------------------------------------------------------------//
/// <summary>
/// Signal the waiting thread that experiment has been submitted and is ready for execution.
/// </summary>
public bool SignalSubmitted()
{
const string STRLOG_MethodName = "SignalSubmitted";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
bool success = false;
if (this.disposed == false)
{
// Signal waiting thread
lock (this.signalSubmitted)
{
Monitor.Pulse(this.signalSubmitted);
}
success = true;
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName);
return(success);
}
public int GetTimeUntilReady()
{
const string STRLOG_MethodName = "GetTimeUntilReady";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
int timeUntilReady = -1;
//
// Check caller access is authorised
//
if (Authorised(authHeader) == true)
{
// Pass on to the equipment engine
timeUntilReady = Global.equipmentManager.GetTimeUntilReady();
}
string logMessage = timeUntilReady.ToString();
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return(timeUntilReady);
}
//-------------------------------------------------------------------------------------------------//
public int GetExecutionTime(string xmlSpecification)
{
int executionTime = -1;
try
{
//
// Parse the XML specification string
//
Specification specification = new Specification(this.xmlNodeEquipmentConfig);
ValidationReport validationReport = specification.Parse(xmlSpecification);
if (validationReport.accepted == true)
{
executionTime = (int)validationReport.estRuntime;
}
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
}
return(executionTime);
}
//---------------------------------------------------------------------------------------//
/// <summary>
/// Initialise the equipment after it has been powered up.
/// </summary>
/// <returns>True if successful.</returns>
public override bool InitialiseEquipment()
{
const string STRLOG_MethodName = "InitialiseEquipment";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
bool success = false;
try
{
success = this.driverMachine.Initialise();
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
}
string logMessage = STRLOG_Success + success.ToString();
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return(success);
}
//-------------------------------------------------------------------------------------------------//
private string BuildAppletParams(ResultInfo resultInfo)
{
string strAppletParams = string.Empty;
try
{
StringWriter sw = new StringWriter();
// Experiment specification
sw.Write(labResults.CreateSpecificationString(resultInfo, STR_SwAppletArgument));
// Experiment results
sw.Write(labResults.CreateResultsString(resultInfo, STR_SwAppletArgument));
strAppletParams = sw.ToString();
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
}
return(strAppletParams);
}
//-------------------------------------------------------------------------------------------------//
public FlexMotionNone(XmlNode xmlNodeEquipmentConfig)
: base(xmlNodeEquipmentConfig)
{
const string STRLOG_MethodName = "FlexMotionNone";
Logfile.WriteCalled(null, STRLOG_MethodName);
//
// Initialise properties
//
//this.powerupDelay = 0;
this.initialiseDelay = 0;
//
// Initialise the flexmotion controller
//
if (this.Initialise() == false)
{
throw new Exception(STRERR_FailedToInitialise);
}
Logfile.WriteCompleted(null, STRLOG_MethodName);
}
public bool ExportReportProductionWeekly()
{
try
{
DefectRateReport defectRateReport = new DefectRateReport();
DateTime date_from = Class.DateTimeControl.StartOfWeek(DayOfWeek.Monday);
DateTime date_to = DateTime.Today.AddDays(-(int)DateTime.Today.DayOfWeek + 7);
DefectRateData defectRateData = new DefectRateData();
defectRateData = defectRateReport.GetDefectRateReportAmountOfTime(date_from, date_to, "B01", "0010");
if (defectRateData.TotalQuantity == 0)
{
return(false);
}
Log.ExportExcelTool exportExcel = new Log.ExportExcelTool();
exportExcel.ExportToTemplateMQCDefectAmountOfTime(date_from, date_to, pathMonth, @"C:\ERP_Temp\MQC_Weekly_Report" + "-" + DateTime.Now.ToString("yyyyMMdd hhmmss") + ".xlsx", defectRateData);
return(true);
}
catch (Exception ex)
{
Logfile.Output(StatusLog.Error, "ExportReportProductionDaiLy()", ex.Message);
return(false);
}
}
public bool ExportReportProductionMonthly()
{
try
{
DefectRateReport defectRateReport = new DefectRateReport();
DateTime date_from = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);
DateTime date_to = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.DaysInMonth(DateTime.Now.Year, DateTime.Now.Month));
DefectRateData defectRateData = new DefectRateData();
defectRateData = defectRateReport.GetDefectRateReportAmountOfTime(date_from, date_to, "B01", "0010");
if (defectRateData.TotalQuantity == 0)
{
return(false);
}
Log.ExportExcelTool exportExcel = new Log.ExportExcelTool();
exportExcel.ExportToTemplateMQCDefectAmountOfTime(date_from, date_to, pathMonth, @"C:\ERP_Temp\MQC_Monthly_Report" + "-" + DateTime.Now.ToString("yyyyMMdd hhmmss") + ".xlsx", defectRateData);
return(true);
}
catch (Exception ex)
{
Logfile.Output(StatusLog.Error, "ExportReportProductionDaiLy()", ex.Message);
return(false);
}
}
public bool ResumePowerdown()
{
const string STRLOG_MethodName = "ResumePowerdown";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
bool success = false;
//
// Check caller access is authorised
//
if (Authorised(authHeader) == true)
{
// Pass on to the equipment engine
success = Global.equipmentManager.ResumePowerdown();
}
string logMessage = success.ToString();
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName, logMessage);
return(success);
}
//-------------------------------------------------------------------------------------------------//
public Result(string xmlExperimentResult)
: base(xmlExperimentResult, new ResultInfo())
{
ResultInfo resultInfo = (ResultInfo)this.experimentResultInfo;
//
// Parse the experiment result
//
try
{
//
// Extract result values from the XML experiment result string and place into ResultInfo
//
resultInfo.voltage = (float)XmlUtilities.GetRealValue(this.xmlNodeExperimentResult, LabConsts.STRXML_voltage, 0);
resultInfo.current = (float)XmlUtilities.GetRealValue(this.xmlNodeExperimentResult, LabConsts.STRXML_current, 0);
resultInfo.powerFactor = (float)XmlUtilities.GetRealValue(this.xmlNodeExperimentResult, LabConsts.STRXML_powerFactor, 0);
resultInfo.speed = XmlUtilities.GetIntValue(this.xmlNodeExperimentResult, LabConsts.STRXML_speed, 0);
}
catch (Exception ex)
{
Logfile.WriteError(ex.Message);
}
}
//-------------------------------------------------------------------------------------------------//
public PowerMeter(ModbusIpMaster master)
{
const string STRLOG_MethodName = "PowerMeter";
Logfile.WriteCalled(null, STRLOG_MethodName);
this.master = master;
//
// Determine the logging level for this class
//
try
{
this.logLevel = (Logfile.LoggingLevels)Utilities.GetIntAppSetting(STRLOG_ClassName);
}
catch
{
this.logLevel = Logfile.LoggingLevels.Minimum;
}
Logfile.Write(Logfile.STRLOG_LogLevel + this.logLevel.ToString());
Logfile.WriteCompleted(null, STRLOG_MethodName);
}
//-------------------------------------------------------------------------------------------------//
public virtual void Create()
{
const string STRLOG_MethodName = "Create";
Logfile.WriteCalled(STRLOG_ClassName, STRLOG_MethodName);
//
// Create local class instances just to check that all is in order
//
ExperimentSpecification experimentSpecification = new ExperimentSpecification(this.appData.labConfiguration, null);
LabExperimentResult labExperimentResult = new LabExperimentResult(this.appData.labConfiguration);
//
// Create instances of lab experiment engines
//
this.appData.labExperimentEngines = new LabExperimentEngine[this.appData.farmSize];
for (int i = 0; i < this.appData.farmSize; i++)
{
this.appData.labExperimentEngines[i] = new LabExperimentEngine(i, this.appData);
}
Logfile.WriteCompleted(STRLOG_ClassName, STRLOG_MethodName);
}
