tbf/TestBenchFramework/BenchControl/MettlerToledo/Multi/ReadStableMassOp.cs

///
/// Copyright (c) 2015-2016 Sensus Metering Systems
///
using System;
using log4net;
using TBF.Boxes;

namespace TBF.BenchControl.MettlerToledo.Multi
{
	/// <summary>
	/// Operation to read more mass values and average them to obtain a more accurate result.
	/// </summary>
	public class ReadStableMassOp : IOperation
	{
		private static readonly ILog log = LogManager.GetLogger(typeof(ReadStableMassOp));
		public override string ToString() { return string.Format("ReadStableMassOp(.,{0},.)", totalReadingsCount); }

		/// Operation specific
		double[] massReadings;
		int currentReadingsCount;

		/// Set by the constructor
		BalanceDev balanceDev;
		int totalReadingsCount;
        double maxSpread;        /// Maximum spread of measurements in kg (otherwise the measurement continues)
        bool method;            /// false = slow (precise), true = fast (immediate)
		DoubleBox result;

		bool started;

		/// <summary>
		/// Events:  BalanceDone, Error
		/// </summary>
		/// <param name="balanceDev">Balance device instance</param>
		/// <param name="result">Reference to the measured mass in kg</param>
		/// <param name="readingsCount">Required mass readings count (>= 3)</param>
        /// <param name="maxSpread">Maximum spread of measurements in kg (otherwise the measurement continues)</param>
        /// <param name="method">Method: false = slow (precise), true = fast (immediate)</param>
		public ReadStableMassOp(BalanceDev balanceDev, ref DoubleBox result, int readingsCount, double maxSpread, bool method)
        {
			if (balanceDev == null) throw new ArgumentNullException("balanceDev");
			this.balanceDev = balanceDev;

            if (readingsCount == 0)
                this.totalReadingsCount = 5;
            else if (readingsCount < 3)
                this.totalReadingsCount = 3;
            else
                this.totalReadingsCount = readingsCount;

            if (maxSpread == 0)
                this.maxSpread = balanceDev.Capacity / 20000;
            else
                this.maxSpread = maxSpread;

            this.method = method;

			this.result = result;

			log.Debug(this.ToString());
        }


		/// <summary>Start this operation</summary>
		public void Start()
        {
			started = false;
			currentReadingsCount = 0;
			massReadings = new double[totalReadingsCount];
			started = BalanceDev.GetImmediateMassMeasurement(balanceDev.IdNr, balanceDev.Name);
		}

		/// <summary>Run this operation</summary>
		/// <returns>
		///		Event.None
		///		Event.BalanceDone
		///		Event.Error . . . . . Current.Tick == null
		/// </returns>
		public Event Run()
		{
			if (currentReadingsCount >= totalReadingsCount) return Event.BalanceDone;	/// Mass has already been calculated
																					
			if (balanceDev.MsrmntState == MsrmntState.Busy) return Event.None;

			if (balanceDev.MsrmntState == MsrmntState.Valid)
			{
				massReadings[currentReadingsCount++] = balanceDev.Mass;

				if (currentReadingsCount == totalReadingsCount)
				{
#if true /// OLD_WAY_OF_MASS_CALCULATION
                    /// Exclude min. and max. value, calculate average
					Array.Sort(massReadings);
					double calcMass = 0;
                    for (int i = 1; i < totalReadingsCount - 1; i++)
                    {
                        calcMass += massReadings[i];
                    }
					calcMass = (calcMass / (totalReadingsCount - 2));
                    log.InfoFormat("ReadStableMassOp.Run() ... valid mass={0} ... returning Event.BalanceDone", calcMass);
					result.Val = calcMass;
					return Event.BalanceDone;       /// Mass has just been calculated
#else
                    double minimum = double.MaxValue;
                    double maximum = double.MinValue;
                    foreach (double val in massReadings)
                    {
                        if (val < minimum) minimum = val;
                        if (val > maximum) maximum = val;
                    }

                    if ((maximum - minimum) <= maxSpread)
                    {
                        double calcMass = 0;
                        for (int i = 0; i < totalReadingsCount; i++)
                        {
                            calcMass += massReadings[i];
                        }
                        calcMass = (calcMass / totalReadingsCount);
                        log.InfoFormat("ReadStableMassOp.Run() ... valid mass={0} ... returning Event.BalanceDone", calcMass);
                        result.Val = calcMass;
                        return Event.BalanceDone;       /// Mass has just been calculated
                    }
                    else
                    {
                        /// Shift data and decrement 'currentReadingsCount'
                        for (int i = 0; i < totalReadingsCount - 1; i++)
                        {
                            massReadings[i] = massReadings[i + 1];
                        }
                        currentReadingsCount--;
                    }
#endif
                }
			}

			BalanceDev.GetImmediateMassMeasurement(balanceDev.IdNr, balanceDev.Name);
			return Event.None;
		}

		/// <summary>Stop this operation</summary>
		public void Stop()
		{
		}
	}
}