// 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); }