Пример #1
0
        /// <summary>
        /// Returns a cal passed DualSense InstalledComponent sibling of the provided InstalledComponent if Single-Sensor mode is enabled
        /// and one exists.  Otherwise, null is returned.  GetDualSenseSibling is a helper method to be used in possible redundant
        /// bump passed scenarios.  The calling method should determine if the sibling has a passed bump status.  This method should only
        /// be called after determining that the instrument is NOT in cal failed state.
        /// </summary>
        public InstalledComponent GetDualSenseSibling(bool singleSensorMode, InstalledComponent bumpFailedComponent)
        {
            if (!singleSensorMode)
            {
                Log.Debug("Single-Sensor mode is currently disabled. A DualSense sibling will NOT be returned.");
                return(null);
            }

            // validate input parameter, only sensors are expected
            if (!(bumpFailedComponent.Component is Sensor))
            {
                return(null);
            }

            Sensor bumpFailedSensor = (Sensor)bumpFailedComponent.Component;

            // an instrument must be docked and discovered
            if (this.Type == DeviceType.Unknown || this.SerialNumber.Length <= 0)
            {
                return(null);
            }

            if (this.Type == DeviceType.TX1)
            {
                // for TX1, a sensor that has a different S/N would be a DualSense sibling
                foreach (InstalledComponent ic in this.InstalledComponents)
                {
                    if (!(ic.Component is Sensor))
                    {
                        continue;
                    }

                    // We do not need to check if the sensor is enabled, because TX1 sensors cannot be disabled.
                    Sensor sensor = (Sensor)ic.Component;

                    if (sensor.Uid == bumpFailedSensor.Uid)
                    {
                        continue;
                    }

                    if (sensor.Type.Code == bumpFailedSensor.Type.Code && !SensorGasResponse.IsFailedCalibrationStatus(sensor.CalibrationStatus))
                    {
                        return(ic);
                    }
                }
            }
            else if (this.Type == DeviceType.VPRO || this.Type == DeviceType.SC)
            {
                // if the failed sensor is not capable of DualSense, then don't search for a sibling;
                // we check the flag here because TX1 does not use it
                if (!bumpFailedSensor.IsDualSenseCapable)
                {
                    return(null);
                }

                // For Ventis Pro Series and SafeCore, a sibling will have a different S/N, but be DualSense capable, and have
                // the same sensor part number and sensor code.  For SafeCore, we do not worry about sensor position because
                // if it were an issue the DS would go into the Sensor Error state.
                foreach (InstalledComponent ic in this.InstalledComponents)
                {
                    if (!(ic.Component is Sensor))
                    {
                        continue;
                    }

                    // Ventis Pro sensors cannot be disabled, but we check because SafeCore sensors can.
                    if (!ic.Component.Enabled)
                    {
                        continue;
                    }

                    Sensor sensor = (Sensor)ic.Component;

                    if (sensor.Uid == bumpFailedSensor.Uid)
                    {
                        continue;
                    }

                    if (sensor.IsDualSenseCapable && sensor.PartNumber == bumpFailedSensor.PartNumber &&
                        sensor.Type.Code == bumpFailedSensor.Type.Code && !SensorGasResponse.IsFailedCalibrationStatus(sensor.CalibrationStatus))
                    {
                        return(ic);
                    }
                }
            }

            // instrument does not support DualSense or no DualSense sibling found
            return(null);
        }
Пример #2
0
        /// <summary>
        /// Returns the instrument-level calibration state based on the state of the installed sensors.
        /// <para>All passed sensors are returned in the passed-in "passedSensors" list.</para>
        /// <para>All failed sensors are returned in the passed-in "failedSensors" list.</para>
        /// </summary>
        /// <param name="passedSensors">
        /// Sensors that passed calibration will be returned in this list.
        /// A null list can be specified to indicate that passed sensors do not need returned.
        /// </param>
        /// <param name="failedSensors">
        /// Sensors that failed calibration will be returned in this list.
        /// A null list can be specified to indicate that failed sensors do not need returned.
        /// </param>
        /// <returns>RedundantSensorPassed will only be returned if SingleSensorMode is enabled and the instrument supports DualSense functionality.</returns>
        public CalibrationState GetInstrumentCalibrationState(bool singleSensorMode, List <InstalledComponent> passedSensors, List <InstalledComponent> failedSensors)
        {
            if (this.Type == DeviceType.Unknown || this.SerialNumber.Length <= 0)
            {
                return(CalibrationState.Unknown);
            }

            CalibrationState instrumentCalState = CalibrationState.Passed;

            if (this.Type == DeviceType.TX1)
            {
                CalibrationState sensor1CalState = CalibrationState.Unknown;
                CalibrationState sensor2CalState = CalibrationState.Unknown;

                foreach (InstalledComponent ic in this.InstalledComponents)
                {
                    if (!(ic.Component is Sensor))
                    {
                        continue;
                    }

                    // We do not need to check if the sensor is enabled, because TX1 sensors cannot be disabled.
                    Sensor sensor = (Sensor)ic.Component;

                    bool failedCal = SensorGasResponse.IsFailedCalibrationStatus(sensor.CalibrationStatus);

                    if ((passedSensors != null) && !failedCal)
                    {
                        passedSensors.Add(ic);
                    }

                    if ((failedSensors != null) && failedCal)
                    {
                        failedSensors.Add(ic);
                    }

                    if (ic.Position == 1)
                    {
                        sensor1CalState = failedCal ? CalibrationState.Failed : CalibrationState.Passed;
                    }
                    if (ic.Position == 2)
                    {
                        sensor2CalState = failedCal ? CalibrationState.Failed : CalibrationState.Passed;
                    }
                }

                if (sensor1CalState == sensor2CalState)
                {
                    instrumentCalState = sensor1CalState;
                }
                else
                {
                    if (singleSensorMode == true)
                    {
                        instrumentCalState = CalibrationState.RedundantSensorPassed;
                    }
                    else
                    {
                        instrumentCalState = CalibrationState.Failed;
                    }
                }
            }
            else if (this.Type == DeviceType.VPRO || this.Type == DeviceType.SC)
            {
                // The caller may not care about which sensors are passed or failed so they may pass in null for
                // both lists which is okay.  However, we need to use the lists to determine the overall calibration
                // state of the instrument.  Instrument cal state is defaulted to Passed above.
                if (passedSensors == null)
                {
                    passedSensors = new List <InstalledComponent>();
                }

                if (failedSensors == null)
                {
                    failedSensors = new List <InstalledComponent>();
                }

                // Will use the dictionary like it's a HashSet.
                Dictionary <string, bool> passedDualSenseCapable = new Dictionary <string, bool>();
                foreach (InstalledComponent ic in this.InstalledComponents)
                {
                    if (!(ic.Component is Sensor))
                    {
                        continue;
                    }

                    // Ventis Pro sensors cannot be disabled, but we check because SafeCore sensors can.
                    if (!ic.Component.Enabled)
                    {
                        continue;
                    }

                    Sensor sensor = (Sensor)ic.Component;

                    // If the sensor failed its last cal or bump add it to the failedSensors list.
                    if (SensorGasResponse.IsFailedCalibrationStatus(sensor.CalibrationStatus))
                    {
                        failedSensors.Add(ic);
                    }
                    else
                    {
                        passedSensors.Add(ic);

                        if (sensor.IsDualSenseCapable)
                        {
                            // We do not use the Add() method because it will throw an exception if we have duplicate keys.
                            passedDualSenseCapable[GetDualSenseCapableKey(sensor)] = sensor.IsDualSenseCapable;
                        }
                    }
                }

                if (failedSensors.Count > 0)
                {
                    if (singleSensorMode == true)
                    {
                        // We will changed this to failed below if we do not find a matching DualSense capable sensor
                        // in the passed list for every failed sensor.
                        instrumentCalState = CalibrationState.RedundantSensorPassed;

                        for (int i = 0; i < failedSensors.Count; i++)
                        {
                            // Only sensors should be in the list.
                            Sensor failedSensor = (Sensor)failedSensors[i].Component;

                            if (failedSensor.IsDualSenseCapable && passedDualSenseCapable.ContainsKey(GetDualSenseCapableKey(failedSensor)))
                            {
                                continue;
                            }

                            // At least one failed sensor does not have a paired sensor that passed.
                            instrumentCalState = CalibrationState.Failed;
                            break;
                        }
                    }
                    else
                    {
                        instrumentCalState = CalibrationState.Failed;
                    }
                }
            }
            else             // All other instrument types.
            {
                // TODO - shouldn't we be adding sensors to passedSensors and failedSensors lists?  - JMP, 6/7/2013
                foreach (InstalledComponent ic in this.InstalledComponents)
                {
                    if (!(ic.Component is Sensor))
                    {
                        continue;
                    }

                    Sensor sensor = (Sensor)ic.Component;
                    if (!sensor.Enabled)
                    {
                        continue;
                    }

                    if (SensorGasResponse.IsFailedCalibrationStatus(sensor.CalibrationStatus) == true)
                    {
                        instrumentCalState = CalibrationState.Failed;
                        break;
                    }
                }
            }

            return(instrumentCalState);
        }