tbf/TBF/Rig/Modbus/TempControl/Easytherm/TControl.cs

///
/// Copyright (c) 2017-2022 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using log4net;
using Common;
using Config.Entities;
using TBF.Rig.Generic;
using TBF.Boxes;

namespace TBF.Rig.Modbus.TempControl.Easytherm
{
    public class TControl : ComponentBase, IDevice, ITempControl
	{
		private static readonly ILog log = LogManager.GetLogger(typeof(TControl));
        public override string ToString() { return string.Format("{0}({1})", ClassName, Cfg.ToString(-1)); }

		readonly TControlCfg easythermCfg;
	    
        Common.Modbus modbus;
        int ticketNumber;       /// 0 .. number of devices registered for regular polling - 1

        public bool MsrmntAvailable { get { return true; } }
        public double MeasuredVal { get { return ReadTemperature(); } }
        public double MsrdValLimLo { get { return Units.ConvertFrom(MsrdUnit, easythermCfg.MsrdValLimLo); } }
        public double MsrdValLimHi { get { return Units.ConvertFrom(MsrdUnit, easythermCfg.MsrdValLimHi); } }
        public Unit MsrdUnit { get { return easythermCfg.MsrdUnit; } }
        public string MsrdFormat { get { return easythermCfg.MsrdFormat; } }
        public string AltString { get { return string.Empty; } }

        private float temperatureSetPoint;
		private bool temperatureSetPointValid;
		private bool temperatureSetPointRequested;

		public float requiredTemp { get { return easythermCfg.ProcParams.RequiredTemp; } }


		public TControl() { }

		public TControl(Generic.IComponentCfg cfg, IList<Generic.IComponent> components)
            : base(cfg)
		{
			easythermCfg = cfg as TControlCfg;
		}

        /// <summary>Initialize this device</summary>
        public override void Initialize()
        {
            modbus = TbfComponents.FindComponent(easythermCfg.ParentName) as Common.Modbus;
            if (modbus == null) throw new Exception("Cannot find " + Name + " parent");

            temperatureSetPointValid = false;
			temperatureSetPointRequested = false;
            modbus.ComponentNames[easythermCfg.ModbusAddress] = Name;
            ticketNumber = modbus.RegisterForPolling();
            log.FatalFormat("{0} initialized: {1}", Name, this);
        }

        /// <summary>Run this device</summary>
        public void RunDeviceBefore()
        {
            if (modbus.ReceivedTelegrams[easythermCfg.ModbusAddress].Count > 0)
            {
                byte[] telegram = modbus.ReceivedTelegrams[easythermCfg.ModbusAddress].Dequeue();
                if (telegram.Length == 7 && telegram[1] == (byte)Function.ReadHoldingRegisters && telegram[2] == 2)
                {
                    ushort value = (ushort)(256 * telegram[3] + telegram[4]);
                    temperatureSetPoint = (float)value * 0.04f;
                    temperatureSetPointValid = true;

                    log.InfoFormat("{0} - Received current temperature setpoint = {1}", Name, temperatureSetPoint);
                }
                else if (telegram.Length == 7 && telegram[1] == (byte)Function.ReadInputRegister && telegram[2] == 2)
                {
                    ushort value = (ushort)(256 * telegram[3] + telegram[4]);
                    actualTemperature = (double)value * 0.04;

                    log.InfoFormat("{0} - Received actual temperature = {1}", Name, actualTemperature);
                }
            }            
        }

        public void RunDeviceAfter()
        {
            if (modbus.IsMyTurn(ticketNumber))
            {
                if (!temperatureSetPointValid && !temperatureSetPointRequested)
                {
                    RequestTemperatureSetpoint();
                    temperatureSetPointRequested = true;
                }
                else if (temperatureSetPointValid && requiredTemp != temperatureSetPoint)
                {
                    SetTemperatureSetpoint(requiredTemp);
                    log.InfoFormat("{0} - Set new temperature setpoint = {1}", Name, requiredTemp);
                }
                else if (modbus.IsMyTurn(ticketNumber))
                {
                    RequestActualTemperature();
                }
            }
        }

        public void StopDevice() { }
		public void StopDevice2() { }


		/// <summary>
		/// Set Easytherm controller to required temperature procedure parameter
		/// </summary>
		/// <returns>true = OK, false = any error</returns>
		public bool SetTemperatureSetpoint()
		{
			return SetTemperatureSetpoint(requiredTemp);
		}

		/// <summary>
		/// Set Easytherm controller to specified temperature
		/// </summary>
		/// <param name="temperature">Temperature in °C</param>
		/// <returns>true = OK, false = any error</returns>
		public bool SetTemperatureSetpoint(float temperature)
		{
			if (temperature != 0 && (temperature < 5 || temperature > 95.0f))
			{
				return false;		/// required temperature out of range
			}

			if (temperatureSetPointValid && (temperature == temperatureSetPoint))
			{
				return true;		/// already set to the required temperature
			}

			if (temperature != 0)	/// temperature==0 disables sending the setpoint
			{
				//ushort temperatureSetpoint = (ushort)temperature;						// in °C
				//ushort destAddress = (ushort)1002;
				ushort usTempSetpoint = (ushort)((10000.0f / 400.0f) * temperature);	// in 0.01% of range (400 °C)
				ushort destAddress = (ushort)2;
				///
				SendValueToEasytherm(Function.PresetSingleRegister, destAddress, usTempSetpoint);
			}

			temperatureSetPoint = temperature;
			temperatureSetPointValid = true;
			return true;
		}

        public void RequestTemperatureSetpoint()
        {
            SendValueToEasytherm(Function.ReadHoldingRegisters, (ushort)2, (ushort)1);  // rel.address=2, 1 word
        }

        public void RequestActualTemperature()
        {
            SendValueToEasytherm(Function.ReadInputRegister, (ushort)0, (ushort)1);     // rel.address=x, 1 word
        }

		void SendValueToEasytherm(Function function, ushort address, ushort value)
		{
			byte[] msg = new byte[8];

			msg[0] = (byte)easythermCfg.ModbusAddress;
			msg[1] = (byte)function;
			msg[2] = (byte)(address >> 8);			/// Relative address Hi
			msg[3] = (byte)(address & 0xFF);		/// Relative address Lo
			msg[4] = (byte)(value >> 8);			/// Data Hi
			msg[5] = (byte)(value & 0xFF);			/// Data Lo

            modbus.SendMessage(msg, Name);
		}



        ///
        /// Operations, etc.
        ///

        double actualTemperature;

        public double ReadTemperature()
        {
            return actualTemperature;
        }


		/// <summary>
		/// Events:  SetOpututsDone, Error
		/// </summary>
		/// <returns>SetOutputsOp instance reference casted to IOperaton</returns>
		public IOperation SetRequiredTemperatureOp()
		{
			return new SetRequiredTemperatureOp(this);
		}

		/// <summary>
		/// Events:  SetOpututsDone, Error
		/// </summary>
		/// <param name="temperature">Reference to a variable for the pressure in Bar</param>
		/// <returns>SetOutputsOp instance reference casted to IOperaton</returns>
		public IOperation SetTemperatureOp(float temperature)
		{
			return new SetTemperatureOp(this, temperature);
		}

		public IOperation ReadTempOp(ref DoubleBox temp)
		{
			return new ReadTempOp(this, ref temp);
		}

		public IOperation ReadTempOp(ref DoubleBox temp, Event eventDone)
		{
			return new ReadTempOp(this, ref temp, eventDone);
		}
	}
}