// Unity
//-------------------------------------
void Awake()
{
m_instruments = new List <InstrumentHandle>();
m_returns = new List <InstrumentHandle>();
m_instance = this;
m_queuedParameters = new Queue <InstrumentParameter>();
}
/// <summary>
/// Executes an instrument read settings operation.
/// </summary>
/// <returns>Docking station event</returns>
public DockingStationEvent Execute()
{
Stopwatch stopwatch = Log.TimingBegin("ALARM EVENT DOWNLOAD");
InstrumentAlarmEventsDownloadEvent instrumentAlarmEventsDownloadEvent = new InstrumentAlarmEventsDownloadEvent(this);
instrumentAlarmEventsDownloadEvent.DockedInstrument = (ISC.iNet.DS.DomainModel.Instrument)Master.Instance.SwitchService.Instrument.Clone();
instrumentAlarmEventsDownloadEvent.DockingStation = Master.Instance.ControllerWrapper.GetDockingStation();
// Retrieve the events.
using (InstrumentController instrumentController = Master.Instance.SwitchService.InstrumentController)
{
// Open the serial port connection needed to communicate with the instrument.
instrumentController.Initialize();
Log.Debug("ALARM EVENTS: Downloading");
instrumentAlarmEventsDownloadEvent.AlarmEvents = instrumentController.GetAlarmEvents();
Log.Debug("ALARM EVENTS: " + instrumentAlarmEventsDownloadEvent.AlarmEvents.Length + " events downloaded.");
} // end-using
// Need to fill in the instrument serial number on our own.
// At the same time, format up details for each alarm event.
foreach (AlarmEvent alarmEvent in instrumentAlarmEventsDownloadEvent.AlarmEvents)
{
alarmEvent.InstrumentSerialNumber = instrumentAlarmEventsDownloadEvent.DockedInstrument.SerialNumber;
}
Log.TimingEnd("ALARM EVENT DOWNLOAD", stopwatch);
return(instrumentAlarmEventsDownloadEvent); // Return the populated event.
}
void Start()
{
// Create the visual objects to modify when a note is pressed
light = new GameObject();
light.transform.parent = transform;
light.transform.localPosition = Vector3.zero;
light.transform.localRotation = Quaternion.AngleAxis(90.0f, Vector3.right);
lightComp = light.AddComponent <Light>();
lightComp.type = LightType.Directional;
lightComp.intensity = 0.0f;
particles = new GameObject();
particles.transform.parent = transform;
particles.transform.position = instrument.transform.position;
particles.transform.localRotation = Quaternion.AngleAxis(-90.0f, Vector3.right);
particleSys = particles.AddComponent <ParticleSystem>();
particleSys.startSpeed = particleMaxSpeed;
particleSys.gravityModifier = 0.2f;
particleSys.startSize = 0.1f;
var emission = particleSys.emission;
emission.enabled = false;
emission.rate = 70;
var shape = particleSys.shape;
shape.shapeType = ParticleSystemShapeType.Hemisphere;
shape.radius = 2.2f;
// Subscribe when notes are played
instCtl = instrument.GetComponent <InstrumentController>();
instCtl.noteDown += NoteDown;
}
// Use this for initialization
void Start()
{
controller = GetComponent <InstrumentController>();
// creates and auto fills default values as needed
instrumentType = new InstrumentType(type.ToString());
color = instrumentType.DefaultColor;
instrument = new Instrument(instrumentName, instrumentType, color, clip);
controller.SetInstrumentProperties(instrument);
}
/// <summary>
/// Determines current charging status of the docked instrument.
/// </summary>
/// <returns>
/// The returned DockingStationEvent is always null.
/// </returns>
/// <exception cref="InstrumentNotDockedException">
/// If instrument is undocked
/// </exception>
/// <exception cref="InstrumentPingFailedException">
/// Failure to turn on the instrument.
/// </exception>
public DockingStationEvent Execute()
{
if (Configuration.DockingStation.Type != DeviceType.MX4 && Configuration.DockingStation.Type != DeviceType.MX6)
{
return(null);
}
if (!Controller.IsDocked())
{
throw new InstrumentNotDockedException();
}
Log.Debug(this.Name + ".Execute");
using (InstrumentController instrumentController = SwitchService.CreateInstrumentController())
{
// Turn on the instrument, the ask it for it's charging status
try
{
// Note that we deliberately do NOT use batch mode. We're only trying to read a very
// few number of messages. So it's not worth the effort and time it takes to negotiate
// faster baud rate and establish a batched connection to the instrument. It's much
// quicker to just read the few registers at the slow baud rate.
instrumentController.Initialize(InstrumentController.Mode.NoLid /* lid not necessary */);
InstrumentSerialNumber = instrumentController.GetSerialNumber();
BatteryCode = instrumentController.GetBatteryCode();
InstrumentChargePhase = instrumentController.GetChargePhase();
Log.Warning(string.Format("{0}: BatteryCode={1}, ChargePhase=\"{2}\"",
this.Name, BatteryCode, InstrumentChargePhase));
}
catch (InstrumentPingFailedException ipef) // Couldn't turn on the instrument?
{
// will get a ping failure if undocked.
if (!Controller.IsDocked())
{
throw new InstrumentNotDockedException();
}
Log.Error(this.Name, ipef);
throw;
}
catch (CommunicationAbortedException cae) // thrown by driver when instrument is undocked.
{
Log.Error(this.Name, cae);
throw new InstrumentNotDockedException();
}
}
return(null);
}
private void Start()
{
if (HostTransform == null)
{
HostTransform = transform;
}
controller = GetComponent <InstrumentController>();
constraints = controller.mixerDimensions;
mainCamera = Camera.main;
}
private void DownloadDatalog()
{
using ( InstrumentController instrumentController = Master.Instance.SwitchService.InstrumentController)
{
instrumentController.Initialize( InstrumentController.Mode.Batch );
DateTime startTime = DateTime.UtcNow;
bool corruptDatalogDetected = false;
_returnEvent.InstrumentSessions = instrumentController.GetDatalog( out corruptDatalogDetected );
TimeSpan elapsedTime = DateTime.UtcNow - startTime;
int corruptSessionsCount = 0;
// For each corrupted session, upload an error to inet.
foreach ( DatalogSession session in _returnEvent.InstrumentSessions )
{
if ( session.CorruptionException != null )
{
corruptSessionsCount++;
// DO NOT CHANGE THE FOLLOWING STRING. THE SERVER IS
// PARSING UPLOADED ERRORS LOOKING FOR THIS PHRASING....
string msg = string.Format( "Corrupt hygiene encountered! - Session {0}\n{1}", Log.DateTimeToString( session.Session ), session.CorruptionException );
Log.Warning( msg );
_returnEvent.Errors.Add( new DockingStationError( msg, DockingStationErrorLevel.Warning, _returnEvent.DockedInstrument.SerialNumber) );
}
}
Log.Debug( string.Format( "DATALOG: {0} sessions successful downloaded from instrument.", _returnEvent.InstrumentSessions.Count ) );
Log.Debug( string.Format( "DATALOG: {0} of those are partial sessions due to corruption.", corruptSessionsCount ) );
Log.Debug( string.Format( "DATALOG: Corruption detected: " + corruptDatalogDetected.ToString() ) );
// If we have zero sessions marked as corrupted, but corruptHygieneDetected is set to true,
// that means the datalog was so corrupted, that a session object couldn't even be created out of it.
// Upload a error.
if ( corruptSessionsCount == 0 && corruptDatalogDetected == true )
{
Log.Debug( "DATALOG: One or more sessions were completely lost due to corruption. " );
// DO NOT CHANGE THE FOLLOWING STRING. THE SERVER IS
// PARSING UPLOADED ERRORS LOOKING FOR THIS PHRASING....
_returnEvent.Errors.Add( new DockingStationError( "Corrupt hygiene encountered!", DockingStationErrorLevel.Warning, _returnEvent.DockedInstrument.SerialNumber ) );
}
Log.Debug( string.Format( "DATALOG: Overall time to download & process: {0}.", elapsedTime ) );
} // end-using
}
/// <summary>
/// Executes an instrument discovery operation.
/// </summary>
/// <returns>Docking station event</returns>
public DockingStationEvent Execute()
{
InstrumentNothingEvent instrumentNothingEvent;
using (InstrumentController instrumentController = SwitchService.CreateInstrumentController())
{
// Create the return event.
instrumentNothingEvent = new InstrumentNothingEvent(this);
// Open the serial port connection needed to communicate with the instrument.
instrumentController.Initialize();
}
return(instrumentNothingEvent);
}
internal static Mock <ISwitchService> GetSwitchServiceMock(Instrument instrument = null, bool isCal = true, InstrumentController instrumentControllerForBump = null)
{
Mock <ISwitchService> switchService = new Mock <ISwitchService>();
InstrumentController instrumentController = isCal ? GetInstrumentControllerMockForCal(instrument).Object
: instrumentControllerForBump;
switchService.SetupAllProperties();
switchService.Setup(x => x.InitialReadSettingsNeeded).Returns(false);
switchService.Setup(x => x.IsInstrumentInSystemAlarm).Returns(false);
switchService.Setup(x => x.Instrument).Returns(instrument);
switchService.Setup(x => x.InstrumentController).Returns(instrumentController);
switchService.Setup(x => x.IsDocked()).Returns(instrument != null);
return(switchService);
}
private void ConstructorInit(PurgeType purgeType, InstrumentController instrumentController, List <GasEndPoint> gasEndPoints, InstrumentGasResponseEvent gasResponseEvent)
{
Log.Assert(instrumentController != null, "instrumentController cannot be null");
_instrumentController = instrumentController;
_purgeType = purgeType;
_returnGasResponseEvent = gasResponseEvent;
// clone the supplied GasEndPoints
foreach (GasEndPoint currentGasEndPoint in gasEndPoints)
{
GasEndPoint purgeGasEndPoint = (GasEndPoint)currentGasEndPoint.Clone();
GasEndPoints.Add(purgeGasEndPoint);
}
}
private void Init()
{
// Create an InstrumentController object to provide command processing functionality.
_instrumentController = Master.Instance.SwitchService.InstrumentController;
// For keeping track of cylinders that have been tried.
_triedGasEndPoints = new Dictionary<GasEndPoint, GasEndPoint>();
// Create the event that will be returned.
_returnEvent = new InstrumentCalibrationEvent( this );
#if TEST
_testOnlySensorCalibrationLimits = new List<SensorCalibrationLimits>();
_testOnlySensorCalibrationLimits.Add(new SensorCalibrationLimits(SensorCode.CO, 60));
_testOnlySensorCalibrationLimits.Add(new SensorCalibrationLimits(SensorCode.H2S, 60));
_testOnlySensorCalibrationLimits.Add(new SensorCalibrationLimits(SensorCode.O2, 60));
_testOnlySensorCalibrationLimits.Add(new SensorCalibrationLimits(SensorCode.CombustibleLEL, 60));
#endif
}
} // TODO SET ON SWITCH SERVICE - USED ONLY BY IDS
//protected DetailsBuilder _detailsBuilder;
#endregion Fields
#region Constructors
private void Init()
{
// Create an InstrumentController object to provide command processing functionality.
_instrumentController = Master.Instance.SwitchService.InstrumentController;
// For keeping track of cylinders that have been tried.
_triedGasEndPoints = new Dictionary <GasEndPoint, GasEndPoint>();
BumpThreshold = SensorGasResponse.DEFAULT_BUMP_THRESHOLD;
/// <summary>
/// Specifies maximum amount of time a bump test may take
/// before it times out and fails.
/// </summary>
BumpTimeout = SensorGasResponse.DEFAULT_BUMP_TIMEOUT;
#if TEST
_biasStateTimeout = 5;
#endif
}
private static string PromptUserToAddInstrument(string basePartNumber, string stationType, string referenceId)
{
string prompt =
string.Format(
PromptToCreateInstrument,
basePartNumber);
if (DialogResult.Yes ==
MessageBox.Show(prompt, @"V E R I F Y", MessageBoxButtons.YesNo, MessageBoxIcon.Question))
{
InstrumentDescription instrument = InstrumentController.CreateInstrument(basePartNumber,
stationType);
if (instrument == null)
{
throw new Exception(string.Format(FailedToFindInstrument, basePartNumber));
}
referenceId = instrument.uuid;
}
return(referenceId);
}
/// <summary>
/// </summary>
/// <returns>Docking station event</returns>
public DockingStationEvent Execute()
{
Stopwatch stopwatch = Log.TimingBegin("ALARM EVENT CLEAR");
InstrumentAlarmEventsClearEvent clearEvent = new InstrumentAlarmEventsClearEvent(this);
clearEvent.DockedInstrument = (ISC.iNet.DS.DomainModel.Instrument)Master.Instance.SwitchService.Instrument.Clone();
clearEvent.DockingStation = Master.Instance.ControllerWrapper.GetDockingStation();
using (InstrumentController instrumentController = Master.Instance.SwitchService.InstrumentController)
{
instrumentController.Initialize();
Log.Debug("Clearing alarm events");
instrumentController.ClearAlarmEvents();
} // end-using
Log.TimingEnd("ALARM EVENT CLEAR", stopwatch);
return(clearEvent);
}
/// <summary>
/// </summary>
/// <returns>Docking station event</returns>
public DockingStationEvent Execute()
{
Stopwatch stopwatch = Log.TimingBegin("DATALOG CLEAR");
InstrumentDatalogClearEvent datalogClearEvent = new InstrumentDatalogClearEvent(this);
datalogClearEvent.DockedInstrument = (ISC.iNet.DS.DomainModel.Instrument)Master.Instance.SwitchService.Instrument.Clone();
datalogClearEvent.DockingStation = Master.Instance.ControllerWrapper.GetDockingStation();
using (InstrumentController instrumentController = Master.Instance.SwitchService.InstrumentController)
{
instrumentController.Initialize();
datalogClearEvent.SessionsCleared = 0;
datalogClearEvent.SessionsCleared = instrumentController.ClearDatalog();
} // end-using
Log.TimingEnd("DATALOG CLEAR", stopwatch);
return(datalogClearEvent);
}
/// <summary>
/// </summary>
/// <returns>Docking station event</returns>
public DockingStationEvent Execute()
{
Stopwatch stopwatch = Log.TimingBegin("MANUAL OPERATIONS CLEAR");
InstrumentManualOperationsClearEvent clearEvent = new InstrumentManualOperationsClearEvent(this);
clearEvent.DockedInstrument = (ISC.iNet.DS.DomainModel.Instrument)Master.Instance.SwitchService.Instrument.Clone();
clearEvent.DockingStation = Master.Instance.ControllerWrapper.GetDockingStation();
using (InstrumentController instrumentController = Master.Instance.SwitchService.InstrumentController)
{
instrumentController.Initialize();
instrumentController.ClearManualGasOperations();
Log.Debug(Name + ": Manual gas operations cleared.");
} // end-using
Log.TimingEnd("MANUAL OPERATIONS CLEAR", stopwatch);
return(clearEvent);
}
/// <summary>
/// Executes an instrument read settings operation.
/// </summary>
/// <returns>Docking station event</returns>
public DockingStationEvent Execute()
{
Stopwatch stopwatch = Log.TimingBegin("MANUAL OPERATIONS DOWNLOAD");
InstrumentManualOperationsDownloadEvent downloadEvent = new InstrumentManualOperationsDownloadEvent(this);
downloadEvent.DockedInstrument = (ISC.iNet.DS.DomainModel.Instrument)Master.Instance.SwitchService.Instrument.Clone();
downloadEvent.DockingStation = Master.Instance.ControllerWrapper.GetDockingStation();
using (InstrumentController instrumentController = Master.Instance.SwitchService.InstrumentController)
{
instrumentController.Initialize(InstrumentController.Mode.Batch);
Log.Debug("MANUAL GAS OPERATIONS: Downloading");
// INS-3145 - Due to a bug in GBPro, a manual gas operation is sometimes logged
// with an invalid sensor resolution (decimal places = 255). When this happens,
// the instrument driver will throw an ArgumentOutOfRangeException. If we
// catch one, we need to tell iNet. We don't rethrow the exception, to prevent
// the docking station from going "unavailable" and instead just treat it
// as if the log was empty. This allows the corrupt log to be cleared.
try
{
downloadEvent.GasResponses = new List <SensorGasResponse>(instrumentController.GetManualGasOperations());
}
catch (ArgumentOutOfRangeException aoore)
{
Log.Error(aoore);
downloadEvent.Errors.Add(new DockingStationError("Corrupt manual gas operations log encountered.", DockingStationErrorLevel.Warning, downloadEvent.DockedInstrument.SerialNumber));
}
Log.Debug("MANUAL GAS OPERATIONS: " + downloadEvent.GasResponses.Count + " downloaded.");
} // end-using
Log.TimingEnd("MANUAL OPERATIONS DOWNLOAD", stopwatch);
return(downloadEvent); // Return the populated event.
}
public Boolean CheckNotes(string noteName)
{
int note = InstrumentController.ConvertToPitch(noteName) + 48;
if (playMode == PlayMode.Continuous)
{
List <Note> sameNotes = notes.Where(x => x.NoteNumber == note).ToList();
if (sameNotes.Count > 0)
{
float currentTime = songTime;
Note closest = sameNotes.Aggregate((x, y) => Math.Abs(GetNoteTime(x) - currentTime) < Math.Abs(GetNoteTime(y) - currentTime) ? x : y);
if (Math.Abs(GetNoteTime(closest) - currentTime) < 1)
{
streak++;
if (streak > 2)
{
return(true);
}
return(false);
}
}
}
else
{
if (notes[noteIndex].NoteNumber == note)
{
streak++;
if (streak > 2)
{
return(true);
}
return(false);
}
}
streak = 0;
return(false);
}
void Awake()
{
m_instance = this;
m_instrumentControlRef = this.gameObject.GetComponent <InstrumentController>();
m_hydraRef = GameObject.Find("__HydraController").GetComponent <HydraController>();
}
private InstrumentNothingEvent DiscoverInstrument()
{
// Create the return event.
InstrumentNothingEvent instrumentNothingEvent = new InstrumentNothingEvent(this);
InstrumentController instrumentController = SwitchService.CreateInstrumentController();
try
{
// Open the serial port connection needed to communicate with the instrument.
instrumentController.Initialize(InstrumentController.Mode.Batch);
// MX4 is the default instrument controller created for MX4 docking stations.
if (instrumentController is MX4)
{
// VPRO instrument controller may need created instead depending on type of docked instrument.
if (instrumentController.GetInstrumentType() == DeviceType.VPRO)
{
// Clean up MX4 controller.
instrumentController.Dispose();
// Create and initialize VPRO controller.
instrumentController = new VPRO();
instrumentController.Initialize(InstrumentController.Mode.Batch);
}
}
// If we make it through InstrumentController.Initialize without throwing, then
// we assume the instrument is now on, or at least it's IrDA is.
InstrumentOff = false;
Stopwatch sw = new Stopwatch();
sw.Start();
// TxRxRetries value is returned by modbuslibrary.dll. It continally increments the value and never resets it back to zero.
// So, before reading data from the instrument, we get the current value. Farther below, when we're finished reading, we get
// the value again, and subtract this starting value to determine how many retries occurred during this particular discovery.
// Getting this starting value also lets us subtract out any of the retries occurring during initializing above.
int startTxRxRetries = instrumentController.Driver.TxRxRetries;
// Retrieve the docked instrument.
instrumentNothingEvent.DockedInstrument = instrumentController.DiscoverDockedInstrument(true);
// INS-8228 RHP v7.6, Service accounts need to perform auto-upgrade on instruments even in error/fail state
Master.Instance.SwitchService.IsInstrumentInSystemAlarm = instrumentController.IsInstrumentInSystemAlarm;
sw.Stop();
int txRxCount = instrumentController.Driver.TxRxCount;
double txRxCountPerSecond = (double)txRxCount / (sw.ElapsedMilliseconds / 1000.0);
int txRxRetries = instrumentController.Driver.TxRxRetries - startTxRxRetries;
Log.Debug(string.Format("Modbus statistics: stopwatch={0}ms, TxRx={1} ({2}/s), retries={3}",
sw.ElapsedMilliseconds, txRxCount, txRxCountPerSecond.ToString("f0"), txRxRetries));
}
catch (InstrumentSystemAlarmException) // SGF Nov-23-2009 DSW-355 (DS2 v7.6)
{
// If the user docked an instrument in system alarm, then just rethrow up to the service
// that invoked this discovery and let it deal with it.
throw;
}
catch (HardwareConfigurationException)
{
// If user failed to reconfigure the docking station hardware, then just rethrow up to the service
// that invoked this discovery and let it deal with it.
throw;
}
catch (Exception e)
{
Log.Error(this.GetType().ToString() + ".Execute.DiscoverDockedInstrument", e);
// ********************************************************************
// See INS-6671 and INS-6682 as to why the second discover was removed.
// ********************************************************************
throw;
} // end-catch
finally
{
instrumentController.Dispose();
}
return(instrumentNothingEvent);
}
/// <summary>
/// Executes an instrument diagnostic operation.
/// </summary>
/// <returns>Docking station event</returns>
public DockingStationEvent Execute()
{
Stopwatch stopwatch = Log.TimingBegin("INSTRUMENT DIAGNOSTICS");
InstrumentDiagnosticEvent instrumentDiagnosticEvent = new InstrumentDiagnosticEvent(this);
instrumentDiagnosticEvent.DockedInstrument = (ISC.iNet.DS.DomainModel.Instrument)Master.Instance.SwitchService.Instrument.Clone();
instrumentDiagnosticEvent.DockingStation = Master.Instance.ControllerWrapper.GetDockingStation();
// Open the serial port connection needed to communicate with the instrument.
using (InstrumentController instrumentController = Master.Instance.SwitchService.InstrumentController)
{
instrumentController.Initialize(InstrumentController.Mode.Batch);
// Cache the diagnostic start time and instrument serial numbers,
// these will be used during each diagnostic object's instantiation.
DateTime diagnosticTime = DateTime.UtcNow;
string instSn = instrumentDiagnosticEvent.DockedInstrument.SerialNumber;
// Download the "General diagnostics" from the instrument.
// The diagnostics that are returned by the instrument will be different and based on the instrument's type.
GeneralDiagnostic generalDiagnostic = new GeneralDiagnostic(instSn, diagnosticTime);
generalDiagnostic.Items = instrumentController.GetGeneralDiagnosticProperties();
foreach (GeneralDiagnosticProperty gdp in generalDiagnostic.Items)
{
Log.Debug("GeneralDiagnosticProperty " + gdp.Name + "=" + gdp.Value);
}
instrumentDiagnosticEvent.Diagnostics.Add(generalDiagnostic);
// Download instrument error log.
ErrorDiagnostic[] errors = instrumentController.GetInstrumentErrors();
List <CriticalError> criticalErrors = new List <CriticalError>();
// we don't need to bother querying the database if there were no errors on
// the instrument that need checked against the database.
if (errors.Length > 0)
{
// INS-4236, 9/10/2014 - only populate criticalErrors list for MX6 instruments.
// MX6 instruments due not have a "current error" register that can be read when it's
// docked to determine if it's currently in a error state. But other instruments do.
// For those instruments that do have this register, we read the register during discovery
// and the docking station will go to "instrument error" state if it's no zero.
// Since we can't do that for MX6, the best we can do is read its error log containing
// historical errors. For each error in the log, we compare to list of errors we
// have in our database that are considered "critical". If we find a match,
// then we set a flag which will cause the docking station to go the "instrument error"
// state when this operation returns the event.
//INS-7715- Need to check if the DS belongs to the Service account, if so fetch all configured errors and compare with the instrument errors.
//If any matches with the errors, then set instrument marked as in critical error.
if ((instrumentDiagnosticEvent.DockedInstrument.Type == DeviceType.MX6) || Configuration.IsRepairAccount())
{
criticalErrors = criticalErrorsList;
//criticalErrors = new CriticalErrorDataAccess().FindAll();
Log.Debug(string.Format("{0} {1} critical errors loaded from database.",
criticalErrors.Count, instrumentDiagnosticEvent.DockedInstrument.Type));
}
}
bool foundCrticalErrorInInstrument = false;
string criticalErroCodeIdentified = string.Empty; // INS-8446 RHP v7.6
foreach (ErrorDiagnostic error in errors)
{
// these values are needed so they can be uploaded to iNet
error.SerialNumber = instSn;
error.Time = diagnosticTime;
instrumentDiagnosticEvent.Diagnostics.Add(error);
Log.Debug("InstrumentError " + error.Code + " on " + Log.DateTimeToString(error.ErrorTime));
// Errors that are logged in the instrument will be compared to the list of critical errors
// downloaded from iNet. If any error code matches then instrument marked as in critical error.
// This list will default to empty for non-MX6 instruments, so it will never find anything, on purpose.
// Exception to that it loads all critical errors for Service accounts for any instrument types - INS-7715.
if (criticalErrors.Exists(ce => ce.Code == error.Code))
{
foundCrticalErrorInInstrument = true;
criticalErroCodeIdentified = error.Code.ToString();
Log.Warning(string.Format("CRITICAL ERROR {0} LOGGED BY INSTRUMENT ON {1}", error.Code, Log.DateTimeToString(error.ErrorTime)));
}
}
if (foundCrticalErrorInInstrument)
{
//if critical errors found then errors will NOT be cleared from the instrument. Setting the "InstrumentInCriticalError"
//property to TRUE will make the docking station to set to "Instrument Error" state.
instrumentDiagnosticEvent.InstrumentInCriticalError = true;
// Setting the "InstrumentCriticalErrorCode" property to hold the Error Code will make the docking station
// display the Error Code on its LCD during "Instrument Error" state. INS-8446 RHP v7.6
instrumentDiagnosticEvent.InstrumentCriticalErrorCode = criticalErroCodeIdentified;
}
else
{
//if no crtical error found then we will clear the errors from the instrument.
instrumentController.ClearInstrumentErrors();
}
} // end-using instrumentController
Log.TimingEnd("INSTRUMENT DIAGNOSTICS", stopwatch);
return(instrumentDiagnosticEvent);
}
/// <summary>
/// Executes an instrument settings update operation.
/// </summary>
/// <returns>Docking station event</returns>
public DockingStationEvent Execute()
{
Stopwatch stopwatch = Log.TimingBegin("INSTRUMENT SETTINGS UPDATE");
// Check for a docked instrument.
if (!Master.Instance.ControllerWrapper.IsDocked())
{
throw new InstrumentNotDockedException();
}
string serialNumber = Master.Instance.SwitchService.Instrument.SerialNumber;
DeviceType instrumentType = Master.Instance.SwitchService.Instrument.Type;
if (serialNumber == string.Empty || instrumentType == DeviceType.Unknown)
{
throw new InstrumentNotDockedException();
}
// Create the return event.
_instrumentSettingsUpdateEvent = new InstrumentSettingsUpdateEvent(this);
// Retrieve the docking station's information.
_instrumentSettingsUpdateEvent.DockingStation = Master.Instance.ControllerWrapper.GetDockingStation();
_instrumentSettingsUpdateEvent.DockedTime = Master.Instance.SwitchService.DockedTime;
// Get the settings from the database to update the instrument with.
Instrument settings = new InstrumentDataAccess().FindApplicableSettings(serialNumber, instrumentType);
// If no instrument settings found, then there's nothing more we can do.
// since we can't update the instrument's settings if we have no settings.
if (settings == null)
{
string errMsg = string.Format("Unable to find instrument settings for S/N \"{0}\"", serialNumber);
_instrumentSettingsUpdateEvent.Errors.Add(new DockingStationError(errMsg, DockingStationErrorLevel.Warning));
return(_instrumentSettingsUpdateEvent);
}
// The settings loaded only apply to the discovered instrument.
// We don't know if the settings loaded are the defaults are not
// so we just set the type to what we searched for above.
settings.Type = instrumentType;
// Merge the loaded settings with our Instrument.
using (_instCtrlr = SwitchService.CreateInstrumentController())
{
// Open the serial port connection needed to communicate with the instrument.
_instCtrlr.Initialize(InstrumentController.Mode.Batch);
// After an instrument settings read, we need to send a command to the instrument
// to have it clear its base unit log. Only SafeCore needs this command.
_instCtrlr.ClearBaseUnits();
// Update the docked instrument.
_instrumentSettingsUpdateEvent.DockedInstrument = UpdateInstrument(settings, serialNumber);
// Settings RefId will contain the ID of the settings used during the Update Event. Otherwise, will be Nullid.
// We place it into the event's Instrument in order to upload it to iNet.
_instrumentSettingsUpdateEvent.DockedInstrument.RefId = settings.RefId;
if (_instrumentSettingsUpdateEvent.DockingStation.ClearPeaksUponDocking)
{
_instCtrlr.ClearInstrumentSensorPeaks(_instrumentSettingsUpdateEvent.DockedInstrument.InstalledComponents);
}
} // end-using
Log.TimingEnd("INSTRUMENT SETTINGS UPDATE", stopwatch);
return(_instrumentSettingsUpdateEvent);
}
// Use this for initialization
protected void Start()
{
cont = GameObject.FindGameObjectWithTag("Instrument").GetComponent <InstrumentController>();
}
/// <summary>
/// Executes a turn off instrument operation.
/// </summary>
/// <returns>A InstrumentTurnOffEvent, which contains the TurnOffAction
/// indicating what exactly the Execute() decided to do.
/// </returns>
/// <exception cref="InstrumentNotDockedException">If an instrument is not docked.</exception>
public DockingStationEvent Execute()
{
string funcName = Name + ".Execute";
Log.Debug(funcName + ", Reason=" + _reason);
InstrumentTurnOffEvent _returnEvent = new InstrumentTurnOffEvent(this);
#if DEBUG
// When debugging, don't turn off the GBPROs since they annoyingly take too long to turn back on.
if (Configuration.DockingStation.Type == DeviceType.GBPRO)
{
_returnEvent.TurnOffAction = TurnOffAction.None;
Log.Info(string.Format("{0}.Execute doing nothing due to DEBUG directive", Name));
return(_returnEvent);
}
#endif
_returnEvent.TurnOffAction = GetTurnOffAction();
if (_returnEvent.TurnOffAction == TurnOffAction.NotSupported)
{
Log.Warning(string.Format("{0}: Docked {1}'s cannot be turned off.", funcName, Configuration.DockingStation.Type));
return(_returnEvent);
}
else if (_returnEvent.TurnOffAction == TurnOffAction.None)
{
Log.Warning(string.Format("{0}: Docked {1} should already be off.", funcName, Configuration.DockingStation.Type));
return(_returnEvent);
}
else
{
if (!Controller.IsDocked())
{
throw new InstrumentNotDockedException();
}
using (InstrumentController instrumentController = SwitchService.CreateInstrumentController())
{
// Note that we specify NoPing. This causes the instrument controller to *not* call the
// driver's connect method.
instrumentController.Initialize(InstrumentController.Mode.NoPing);
try
{
if (_returnEvent.TurnOffAction == TurnOffAction.Shutdown)
{
// Even the instruments which cannot shutdown will have this called
// so their sensors get turned off.
instrumentController.TurnOff();
}
else if (_returnEvent.TurnOffAction == TurnOffAction.TurnOffSensors)
{
if (instrumentController.GetOperatingMode() == OperatingMode.WarmingUp)
{
// MX6 instrument does not support going to Charging mode when it is currently WarmingUp.
// So we need to try again later after the instrument has transitioned to Running.
_returnEvent.TurnOffAction = TurnOffAction.Postponed;
Log.Debug(funcName + ", WAITING FOR WARM UP TO COMPLETE. TURN OFF POSTPONED.");
}
else
{
// This should only need to be called for MX6 rechargeable instruments.
instrumentController.TurnOnSensors(false, false);
}
}
}
catch (CommunicationException ce)
{
Log.Debug(funcName + " caught CommunicationException: " + (Log.Level >= LogLevel.Trace ? ce.ToString() : ce.Message));
Log.Debug(funcName + " FAILED. Instrument might already be in OFF state.");
}
}
}
return(_returnEvent);
}
// Start is called before the first frame update
void Start()
{
iController = GetComponent <InstrumentController>();
text = FindObjectOfType <TextScreenControl>();
audioC = FindObjectOfType <MasterAudioController>();
}
public void SetInstrumentController(InstrumentController instrument)
{
this.instrument = instrument;
}
// Use this for initialization
void Start()
{
controller = GetComponent <InstrumentController>();
rend = GetComponent <Renderer>();
}
/// <summary>
/// Creates a new instance of an InstrumentPurgeOperation class.
/// </summary>
public InstrumentPurgeOperation(PurgeType purgeType, InstrumentController instrumentController, List <GasEndPoint> gasEndPoints, InstrumentGasResponseEvent gasResponseEvent, List <SensorGasResponse> currentPassSGRList)
{
_currentPassSGRList = currentPassSGRList;
ConstructorInit(purgeType, instrumentController, gasEndPoints, gasResponseEvent);
}
/// <summary>
/// Creates a new instance of an InstrumentPurgeOperation class.
/// </summary>
public InstrumentPurgeOperation(PurgeType purgeType, InstrumentController instrumentController, List <GasEndPoint> gasEndPoints, InstrumentGasResponseEvent gasResponseEvent)
{
ConstructorInit(purgeType, instrumentController, gasEndPoints, gasResponseEvent);
}
/// <summary>
/// Executes an instrument bump test operation.
/// </summary>
/// <returns>The completed event for this bump test.</returns>
/// <exception cref="FailedBumpTestException">
/// If anything extraordinary happened during the bump test.
/// </exception>
public DockingStationEvent Execute()
{
//Clear if any flags before initiating calibration once again
Pump.IsBadPumpTubing = false; // iNetDS
Master.Instance.SwitchService.BadPumpTubingDetectedDuringCal = false; // iNetDS
Master.Instance.SwitchService.BadPumpTubingDetectedDuringBump = false; // iNetDS
Stopwatch operationStopwatch = Log.TimingBegin("INSTRUMENT BUMP TEST"); // iNetDS
_returnEvent = new InstrumentBumpTestEvent(this);
_returnEvent.DockedInstrument = this.Instrument; // TODO
_returnEvent.DockingStation = this.DockingStation; // TODO
//_detailsBuilder = new DetailsBuilder(EventDetails); // _detailsBuilder = new DetailsBuilder(InstrumentHelper.EventDetails); // IDS
//Throw Exception if Instrument is undocked
if (!Master.Instance.ControllerWrapper.IsDocked())
{
throw new InstrumentNotDockedException();
}
_returnEvent.Trigger = Trigger;
_returnEvent.IsSensorFailureModeEnabled = IsSensorFailureModeEnabled; // DSW-1034 RHP Tango TODO IDS
_returnEvent.IsSCSensorFailureModeEnabled = IsSCSensorFailureModeEnabled; // DSW-1068 RHP v9.5 TODO IDS
Log.Debug(string.Format("{0}.Execute {1}", Name, _returnEvent.DockedInstrument.SerialNumber));
// Add the detail header.
//_detailsBuilder.Add("", "DETAILS_BUMP_TEST_HEADER", string.Empty); // IDS
//_detailsBuilder.AddNewLine(); // IDS
//_detailsBuilder.Add(" ", "DETAILS_INSTRUMENT_BUMPTHRESHOLD", this.BumpThreshold); // IDS
//_detailsBuilder.Add(" ", "DETAILS_INSTRUMENT_BUMPTIMEOUT", this.BumpTimeout); // IDS
_returnEvent.DockedInstrument.InstalledComponents
= InstrumentController.SortSensorsByBumpOrder(_returnEvent.DockedInstrument.InstalledComponents); //
#region LogDebug
Log.Debug("Candidate gases...");
int pointCount = 0;
foreach (GasEndPoint gasEndPoint in GasEndPoints)
{
string msg = "GasEndPoint #" + ++pointCount;
Log.Debug(msg);
Cylinder cyl = gasEndPoint.Cylinder;
msg = "...Pos " + gasEndPoint.Position
+ ", FactID=" + cyl.FactoryId
+ ", Part=" + cyl.PartNumber
+ ", Fresh=" + cyl.IsFreshAir
+ ", ZeroAir=" + cyl.IsZeroAir
+ ", Pressure=" + cyl.Pressure.ToString();
if (gasEndPoint.Cylinder.Volume != DomainModelConstant.NullInt)
{
msg += ", Vol=" + gasEndPoint.Cylinder.Volume;
}
Log.Debug(msg);
msg = "......";
foreach (GasConcentration gasCon in cyl.GasConcentrations)
{
msg += "[" + gasCon.Type.Code + " ";
msg += (gasCon.Concentration == DomainModelConstant.NullDouble) ? "fresh" : gasCon.Concentration.ToString();
msg += "]";
}
Log.Debug(msg);
}
Log.Debug("Going to BUMP sensors in following ORDER...");
int bumpOrder = 1;
foreach (InstalledComponent ic in _returnEvent.DockedInstrument.InstalledComponents)
{
if (!(ic.Component is Sensor))
{
continue; // It its not a sensor, ignore it.
}
Log.Debug("...#" + bumpOrder++ + ", Position " + ic.Position + ", UID=" + ic.Component.Uid + ", " + ic.Component.Type.Code);
}
#endregion
// Open the serial port connection needed to communicate with the instrument.
try
{
Stopwatch pingStopwatch = Log.TimingBegin("BUMP - PING");
_instrumentController.Initialize();
// Add a new line and section to the details.
//_detailsBuilder.AddNewLine();
Log.TimingEnd("BUMP - PING", pingStopwatch);
// See if there are any already failed sensors - go to calibration if there are.
// TODO move this section for IDS prior to initiating Bump Test, probably something similar to iNetDS Scheduler
// Load the BumpTimout and BumpThreshold from the database needed to perform the bump.
LoadBumpLimits(); // TODO update for IDS, LOAD THESE INTO INSTRUMETN ACTION BEFORE BUMP TEST
BumpInstrument();
// Need to determine the next time this instrument will be bumped.
// Put this date into the event so it can be uploaded to iNet, and also
// update the global next date that's held in the switch service.
_returnEvent.NextUtcScheduledDate = Master.Instance.SwitchService.NextUtcBumpDate
= Master.Instance.Scheduler.GetNextGasOperationDate(_returnEvent);
}
finally
{
_instrumentController.Dispose();
}
Log.TimingEnd("INSTRUMENT BUMP TEST", operationStopwatch);
// IDS Updates Sensor's Bump Test Status on Cached Instrument - TODO TO BE HANDLED IN EVENT PROCESSOR FOR IDS.
// Send back the results.
return(_returnEvent);
}
