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

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

namespace TBF.BenchControl.MettlerToledo.Standard
{
	/// <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); }

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

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

		bool measurementCompleted;

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

			this.totalReadingsCount = (readingsCount < 4) ? 5 : readingsCount;		/// readingsCount is at least 4
			this.maxSpread = (maxSpread == 0) ? (balanceDev.Capacity / 20000.0) : maxSpread;
			this.method = method;

			this.result = result;

			massReadings = new double[totalReadingsCount];
			currentReadingsCount = 0;
			measurementCompleted = false;

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

		/// <summary>Start this operation</summary>
		public void Start()
        {
			currentReadingsCount = 0;
			measurementCompleted = false;

            if (method)
                balanceDev.GetImmediateMassMeasurement();
            else
                balanceDev.GetStableMassMeasurement();
		}

		/// <summary>Run this operation</summary>
		/// <returns>
		///		Event.None
		///		Event.BalanceDone
		///		Event.Error . . . . . Current.Tick == null
		/// </returns>
		public Event Run()
		{
			if (measurementCompleted) return Event.BalanceDone;

			if (balanceDev.MsrmntState == MsrmntState.Busy)
			{
				return Event.None;	/// Wait for a mass measurement
			}

			if (balanceDev.MsrmntState == MsrmntState.Valid)
			{
				/// Save the measurement
				if (currentReadingsCount < totalReadingsCount)
				{
					massReadings[currentReadingsCount++] = balanceDev.Mass;
				}
				else
				{
					/// Shift data in the (already full) buffer, save the mass into the last buffer item
					for (int i = 1; i < totalReadingsCount; i++)
					{
						massReadings[i - 1] = massReadings[i];
					}
					massReadings[totalReadingsCount - 1] = balanceDev.Mass;
				}
			}

			if (currentReadingsCount >= totalReadingsCount)
			{
#if STABLE_MASS_EXTRAS
				if (method)
				{
					/// Immediate mass measurement, end condition calculated below

					Array.Sort(massReadings);
					if ((massReadings[totalReadingsCount - 2] - massReadings[1]) <= maxSpread)
					{
						double massSum = 0;
						for (int i = 1; i < totalReadingsCount - 1; i++) massSum += massReadings[i];
						result.Val = (massSum / (totalReadingsCount - 2));
						log.InfoFormat("ReadStableMassOp.Run() ... valid mass={0} ... returning Event.BalanceDone", result.Val);

						measurementCompleted = true;
						return Event.BalanceDone;       /// Mass has just been calculated
					}
				}
				else
#endif
				{
					/// Stable mass measurement

					/// Sort, exclude min. and max. values, calculate the average
					Array.Sort(massReadings);
					double massSum = 0;
					for (int i = 1; i < totalReadingsCount - 1; i++) massSum += massReadings[i];
					result.Val = (massSum / (totalReadingsCount - 2));
					log.InfoFormat("ReadStableMassOp.Run() ... valid mass={0} ... returning Event.BalanceDone", result.Val);

					measurementCompleted = true;
					return Event.BalanceDone;       /// Mass has just been calculated
				}
			}


			if (measurementCompleted)
			{
				return Event.BalanceDone;
			}
			else
			{
				///
				/// Start a new measurement
				///
				if (method)
					balanceDev.GetImmediateMassMeasurement();
				else
					balanceDev.GetStableMassMeasurement();

				return Event.None;
			}
		}

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