302 lines
9.6 KiB
C#
302 lines
9.6 KiB
C#
///
|
|
/// Copyright (c) 2015 Sensus Metering Systems
|
|
/// Author: Milan Hanajik
|
|
///
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
using System.IO.Ports;
|
|
using log4net;
|
|
using Config.Entities;
|
|
using TBF.BenchControl.Generic;
|
|
using TBF.Boxes;
|
|
|
|
namespace TBF.BenchControl.MettlerToledo.Multi
|
|
{
|
|
/// <summary>
|
|
/// Mettler Toledo ICS4_5 Weighting terminal connected via serial interface (RS232)
|
|
/// </summary>
|
|
/// <note>
|
|
/// Implemented and tested on 15.10.2013 by Milan Hanajik
|
|
/// </note>
|
|
public class BalanceDev : ComponentBase, IDevice, GenericDevices.IBalance
|
|
{
|
|
/// <summary>
|
|
/// Info: StartMassMeasurement() and "Balnce response = .., Mass = ..."
|
|
/// Warn: Start measurement when busy is true
|
|
/// </summary>
|
|
private static readonly ILog log = LogManager.GetLogger(typeof(BalanceDev));
|
|
public override string ToString() { return string.Format("MettlerToledo.Multi.Balance({0})", Cfg.ToString(1)); }
|
|
|
|
protected readonly BalanceCfg balanceCfg;
|
|
protected static BalanceCfg balance1Cfg;
|
|
|
|
/// <summary>
|
|
/// Enumeration of balances via static fields and methods
|
|
/// </summary>
|
|
static int nextBalanceIdx = 0;
|
|
public static new void ResetStaticProperties()
|
|
{
|
|
nextBalanceIdx = 0;
|
|
}
|
|
public static int BalancesCount { get { return nextBalanceIdx; } }
|
|
public static BalanceDev[] Balances;
|
|
public static float[] Masses;
|
|
///
|
|
protected int balanceNr; /// 0-based balance number
|
|
|
|
protected static SerialPort serialPort;
|
|
protected static StringBuilder stringBuilder;
|
|
|
|
public int BalanceNr { get { return balanceNr; } }
|
|
public int IdNr { get { return balanceCfg.IdNr; } }
|
|
public float Capacity { get { return balanceCfg.Capacity; } }
|
|
public float Resolution { get { return balanceCfg.Resolution; } }
|
|
public int EmptyTimeSec { get { return balanceCfg.EmptyTimeSec; } }
|
|
|
|
/// <summary>The state of the mass measurement</summary>
|
|
public MsrmntState MsrmntState { get { return msrmntState; } }
|
|
protected static MsrmntState msrmntState;
|
|
|
|
/// <summary>The mass after StartMassMeasurement() when MsrmntState == MsrmntState.Valid</summary>
|
|
public float Mass { get { return Masses[balanceNr]; } }
|
|
|
|
/// <summary>The time stamp after StartMassMeasurement() when MsrmntState == MsrmntState.Valid</summary>
|
|
public int MsrmntTimeStamp { get { return msrmntTimeStamp; } }
|
|
protected int msrmntTimeStamp;
|
|
|
|
public string Format { get { return balanceCfg.Format; } }
|
|
|
|
public BalanceDev()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructor
|
|
/// </summary>
|
|
/// <param name="cfg">Balance properties</param>
|
|
public BalanceDev(BalanceCfg cfg)
|
|
: base(cfg)
|
|
{
|
|
balanceCfg = cfg;
|
|
if (cfg.IdNr == 1) balance1Cfg = cfg;
|
|
|
|
balanceNr = nextBalanceIdx++;
|
|
Masses = new float[nextBalanceIdx]; /// (re)initialize the static array of masses of all balances
|
|
///
|
|
if (Balances == null || Balances.Length < nextBalanceIdx)
|
|
{
|
|
BalanceDev[] balancesSoFar = Balances;
|
|
Balances = new BalanceDev[nextBalanceIdx];
|
|
if (balancesSoFar != null) for (int i = 0; i < balancesSoFar.Length; i++) Balances[i] = balancesSoFar[i];
|
|
Balances[nextBalanceIdx - 1] = this;
|
|
}
|
|
|
|
log.Debug(this.ToString());
|
|
}
|
|
|
|
public void Initialize()
|
|
{
|
|
msrmntState = MsrmntState.Failed; /// Data not valid yet
|
|
|
|
if (balanceCfg.DebugLevel == DebugMode.Simulate) return;
|
|
|
|
if (balanceCfg.IdNr == 1)
|
|
{
|
|
stringBuilder = new StringBuilder(40);
|
|
string comPortName = "COM" + balanceCfg.ComPortNr.ToString();
|
|
serialPort = new SerialPort(comPortName, balanceCfg.BaudRate, balanceCfg.Parity, balanceCfg.DataBits, balanceCfg.StopBits);
|
|
serialPort.Handshake = balanceCfg.Handshake;
|
|
serialPort.Open();
|
|
}
|
|
|
|
log.FatalFormat("Successfully initialized device {0}", ToString());
|
|
}
|
|
|
|
public bool IsEmpty()
|
|
{
|
|
return (Mass <= balanceCfg.Empty);
|
|
}
|
|
|
|
public bool IsEmpty(float mass)
|
|
{
|
|
return (mass <= balanceCfg.Empty);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a stable mass measurement
|
|
/// </summary>
|
|
public static bool GetStableMassMeasurement(int scaleId, string name)
|
|
{
|
|
if (balance1Cfg.DebugLevel == DebugMode.Simulate) return true;
|
|
|
|
if (msrmntState == MsrmntState.Busy ||
|
|
msrmntState == MsrmntState.Busy1 ||
|
|
msrmntState == MsrmntState.Busy2 ||
|
|
msrmntState == MsrmntState.Busy3)
|
|
{
|
|
log.WarnFormat("{0} - GetStableMassMeasurement() returns false ... measurementState == {1}", name, msrmntState.ToString());
|
|
return false;
|
|
}
|
|
|
|
msrmntState = (MsrmntState)((int)MsrmntState.Busy + scaleId);
|
|
stringBuilder.Clear();
|
|
string serialData = string.Format("AR WT0{0}01\r\n", scaleId);
|
|
serialPort.Write(serialData);
|
|
log.InfoFormat("{0} - GetStableMassMeasurement() ... \"{1}\" sent", name, serialData);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get an immediate mass measurement
|
|
/// </summary>
|
|
public static bool GetImmediateMassMeasurement(int scaleId, string name)
|
|
{
|
|
if (balance1Cfg.DebugLevel == DebugMode.Simulate) return true;
|
|
|
|
if (msrmntState == MsrmntState.Busy ||
|
|
msrmntState == MsrmntState.Busy1 ||
|
|
msrmntState == MsrmntState.Busy2 ||
|
|
msrmntState == MsrmntState.Busy3)
|
|
{
|
|
log.WarnFormat("{0} - GetImmediateMassMeasurement() returns false ... measurementState == {1}", name, msrmntState.ToString());
|
|
return false;
|
|
}
|
|
|
|
msrmntState = (MsrmntState)((int)MsrmntState.Busy + scaleId);
|
|
stringBuilder.Clear();
|
|
string serialData = string.Format("AR WT0{0}01\r\n", scaleId);
|
|
serialPort.Write(serialData);
|
|
log.InfoFormat("{0} - GetImmediateMassMeasurement() ... \"{1}\" sent", name, serialData);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parse characters received from the serial port
|
|
/// </summary>
|
|
public virtual void RunDeviceBefore()
|
|
{
|
|
if (balanceCfg.DebugLevel == DebugMode.Simulate)
|
|
{
|
|
Masses[balanceNr] = TestBenchSim.GetSimMass(balanceNr);
|
|
msrmntState = MsrmntState.Valid;
|
|
msrmntTimeStamp = StateMachine.Time;
|
|
return;
|
|
}
|
|
|
|
if (balanceCfg.IdNr != 1) return;
|
|
|
|
log.DebugFormat("{0} - RunDevice()", Name);
|
|
|
|
///
|
|
/// Communication runs only when the state is MsrmntState.Busy#
|
|
///
|
|
if (msrmntState != MsrmntState.Busy1 &&
|
|
msrmntState != MsrmntState.Busy2 &&
|
|
msrmntState != MsrmntState.Busy3)
|
|
{
|
|
return;
|
|
}
|
|
|
|
string justReceived = serialPort.ReadExisting();
|
|
if (justReceived != null && justReceived.Length > 0)
|
|
{
|
|
log.DebugFormat("RunDevice() received {0}", justReceived);
|
|
stringBuilder.Append(justReceived);
|
|
}
|
|
|
|
string currentBuffer = stringBuilder.ToString();
|
|
int eolPos = currentBuffer.IndexOf("\r\n");
|
|
if (eolPos >= 0)
|
|
{
|
|
log.InfoFormat("eolPos = {0}", eolPos);
|
|
|
|
msrmntTimeStamp = StateMachine.Time;
|
|
int balanceIdNr = (int)msrmntState - (int)MsrmntState.Busy;
|
|
|
|
/// Get part of the string before EOL
|
|
string received = currentBuffer.Substring(0, eolPos);
|
|
|
|
/// Put the rest back to the string builder
|
|
stringBuilder.Clear();
|
|
if (currentBuffer.Length > eolPos + 2)
|
|
{
|
|
stringBuilder.Append(currentBuffer.Substring(eolPos + 2));
|
|
}
|
|
|
|
if (received.Length == 19 && received.Substring(0, 6).Equals("AR A \""))
|
|
{
|
|
string weightStr = received.Substring(6, 12);
|
|
while ((weightStr[0] == ' ') && (weightStr.Length > 1))
|
|
{
|
|
weightStr = weightStr.Substring(1, weightStr.Length - 1);
|
|
}
|
|
|
|
float weight = 0;
|
|
if (Utils.TryParseSFloat(weightStr, out weight))
|
|
{
|
|
Masses[balanceIdNr - 1] = weight * Balances[balanceIdNr - 1].Resolution;
|
|
log.InfoFormat("Balance({0}) Valid response=\"{1}<cr>\", Mass = {2}kg", balanceIdNr, received, Masses[balanceIdNr - 1]);
|
|
|
|
msrmntState = MsrmntState.Valid;
|
|
}
|
|
else
|
|
{
|
|
log.WarnFormat("Balance({0}) Failed response=\"{1}<cr>\", Error 1 !!!", balanceIdNr, received);
|
|
msrmntState = MsrmntState.Failed;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Balances[balanceIdNr - 1].msrmntState = MsrmntState.Failed;
|
|
log.WarnFormat("Balance({0}) Failed response=\"{1}<cr>\", Error 2 !!!", balanceIdNr, received);
|
|
msrmntState = MsrmntState.Failed;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>Run this device</summary>
|
|
public void RunDeviceAfter()
|
|
{
|
|
}
|
|
|
|
/// <summary>Stop this device</summary>
|
|
public void StopDevice()
|
|
{
|
|
if (balanceCfg.IdNr == 1 && serialPort != null) serialPort.Close();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Events: BalanceDone, Error
|
|
/// </summary>
|
|
/// <param name="result">Reference to a variable for 'tara' in kg</param>
|
|
/// <returns>TaringOp instance reference casted to IOperaton</returns>
|
|
public IOperation TaringOp(ref FloatBox tara)
|
|
{
|
|
return new TaringOp(this, ref tara);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Events: BalanceDone, Error
|
|
/// </summary>
|
|
/// <param name="result">Reference to a variable for the measured mass in kg</param>
|
|
/// <returns>ReadMassOp instance reference casted to IOperaton</returns>
|
|
public IOperation ReadMassOp(ref FloatBox mass)
|
|
{
|
|
return new ReadMassOp(this, ref mass);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Events: BalanceDone, Error
|
|
/// </summary>
|
|
/// <param name="result">Reference to a variable for the measured mass in kg</param>
|
|
/// <param name="readingsCount">Required mass readings count (>= 3)</param>
|
|
/// <returns>ReadMassAverageOp instance reference casted to IOperaton</returns>
|
|
public IOperation ReadStableMassOp(ref FloatBox mass, int readingsCount)
|
|
{
|
|
return new ReadStableMassOp(this, ref mass, readingsCount);
|
|
}
|
|
}
|
|
}
|