337 lines
13 KiB
C#
337 lines
13 KiB
C#
///
|
|
/// Copyright (c) 2022 Sensus Slovensko a.s.
|
|
///
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using log4net;
|
|
using Common;
|
|
using Config.Entities;
|
|
using TBF.Boxes;
|
|
using TBF.Rig.GenericDevices;
|
|
|
|
namespace TBF.Rig.Modbus.TempControl.Novus
|
|
{
|
|
public class TControl : ComponentBase, Generic.IDevice, ITempControl, ISequenceCondition
|
|
{
|
|
private static readonly ILog log = LogManager.GetLogger(typeof(TControl));
|
|
public override string ToString() { return string.Format("{0}({1})", ClassName, Cfg.ToString(-1)); }
|
|
|
|
const UInt16 SetpointAddress = 0; /// Temperature setpoint address
|
|
const UInt16 ProcessValueAddress = 1; /// Actual temperature address
|
|
const UInt16 Status1Address = 6; /// Status word 1 address
|
|
const UInt16 FWVersionAddress = 7; /// Firmware version address
|
|
const UInt16 ControllerIdAddress = 8; /// Controller ID address
|
|
const UInt16 Status2Address = 9; /// Status word 2 address
|
|
const UInt16 Status3Address = 10; /// Status word 3 address
|
|
|
|
readonly TControlCfg novusCfg;
|
|
|
|
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, novusCfg.MsrdValLimLo); } }
|
|
public double MsrdValLimHi { get { return Units.ConvertFrom(MsrdUnit, novusCfg.MsrdValLimHi); } }
|
|
public Unit MsrdUnit { get { return novusCfg.MsrdUnit; } }
|
|
public string MsrdFormat { get { return novusCfg.MsrdFormat; } }
|
|
public string AltString { get { return string.Empty; } }
|
|
|
|
public double SetpointVal
|
|
{
|
|
get { return temperatureSetpoint; }
|
|
set { SetTemperatureSetpoint(value); }
|
|
}
|
|
///
|
|
public void IncreaseSetpoint()
|
|
{
|
|
double tempStepC = isFahrenheit ? Units.ConvertFrom(Unit.F, novusCfg.SetpStep) : novusCfg.SetpStep;
|
|
|
|
double newSetpoint;
|
|
if (novusCfg.RoundToSetpStep)
|
|
{
|
|
double roundedSetpoint = tempStepC * Math.Round(temperatureSetpoint / tempStepC);
|
|
newSetpoint = (roundedSetpoint <= temperatureSetpoint) ? (roundedSetpoint + tempStepC) : roundedSetpoint;
|
|
}
|
|
else
|
|
{
|
|
newSetpoint = temperatureSetpoint + tempStepC;
|
|
}
|
|
|
|
SetTemperatureSetpoint(Math.Min(newSetpoint, 95.0));
|
|
}
|
|
///
|
|
public void DecreaseSetpoint()
|
|
{
|
|
double tempStepC = isFahrenheit ? Units.ConvertFrom(Unit.F, novusCfg.SetpStep) : novusCfg.SetpStep;
|
|
|
|
double newSetpoint;
|
|
if (novusCfg.RoundToSetpStep)
|
|
{
|
|
double roundedSetpoint = tempStepC * Math.Round(temperatureSetpoint / tempStepC);
|
|
newSetpoint = (roundedSetpoint >= temperatureSetpoint) ? (roundedSetpoint - tempStepC) : roundedSetpoint;
|
|
}
|
|
else
|
|
{
|
|
newSetpoint = temperatureSetpoint - tempStepC;
|
|
}
|
|
|
|
SetTemperatureSetpoint(Math.Max(newSetpoint, 5.0));
|
|
}
|
|
|
|
|
|
bool novusDataValid;
|
|
bool temperatureSetPointValid { get { return novusDataValid; } }
|
|
|
|
Int16 status1;
|
|
Int16 status2;
|
|
Int16 status3;
|
|
Int16 fwVersion;
|
|
Int16 controllerId;
|
|
double temperatureSetpoint;
|
|
double actualTemperature;
|
|
|
|
bool isHeating { get { return (status2 & (1 << 11)) != 0; } } /// Output 1: Heating
|
|
bool isCooling { get { return (status2 & (1 << 12)) != 0; } } /// Output 2: Cooling
|
|
bool isFahrenheit { get { return (status2 & (1 << 9)) != 0; } }
|
|
|
|
|
|
public TControl() { }
|
|
|
|
public TControl(Generic.IComponentCfg cfg, IList<Generic.IComponent> components)
|
|
: base(cfg)
|
|
{
|
|
novusCfg = cfg as TControlCfg;
|
|
|
|
CreateConditions(true);
|
|
}
|
|
|
|
/// <summary>Initialize this device</summary>
|
|
public override void Initialize()
|
|
{
|
|
novusDataValid = false;
|
|
|
|
if (novusCfg.DebugLevel == DebugMode.Simulate)
|
|
{
|
|
actualTemperature = 22;
|
|
temperatureSetpoint = 18;
|
|
log.FatalFormat("{0} simulated: {1}", Name, this);
|
|
}
|
|
else
|
|
{
|
|
modbus = TbfComponents.FindComponent(novusCfg.ParentName) as Common.Modbus;
|
|
if (modbus == null) throw new Exception("Cannot find " + Name + " parent");
|
|
|
|
modbus.ComponentNames[novusCfg.ModbusAddress] = Name;
|
|
//ticketNumber = modbus.RegisterForPolling();
|
|
|
|
log.FatalFormat("{0} initialized: {1}", Name, this);
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>Run this device</summary>
|
|
public void RunDeviceBefore()
|
|
{
|
|
if (DebugLevel != DebugMode.Simulate && DebugLevel != DebugMode.FailureDuringOperation)
|
|
{
|
|
while (modbus.ReceivedTelegrams[novusCfg.ModbusAddress].Count > 0)
|
|
{
|
|
byte[] telegram = modbus.ReceivedTelegrams[novusCfg.ModbusAddress].Dequeue();
|
|
|
|
if (telegram.Length == 5)
|
|
{
|
|
log.InfoFormat("[{0}] received 5 bytes", Name);
|
|
}
|
|
else if (telegram.Length == 27 && telegram[1] == (byte)Function.ReadHoldingRegisters && telegram[2] == 22)
|
|
{
|
|
Int16[] values = new Int16[11];
|
|
for (int i = 0; i < values.Length; i++)
|
|
{
|
|
values[i] = (Int16)(256 * telegram[2 * i + 3] + telegram[2 * i + 4]
|
|
- ((telegram[2 * i + 3] & 0x80) != 0 ? 65536 : 0));
|
|
}
|
|
|
|
status1 = values[Status1Address];
|
|
status2 = values[Status2Address];
|
|
status3 = values[Status3Address];
|
|
fwVersion = values[FWVersionAddress];
|
|
controllerId = values[ControllerIdAddress];
|
|
|
|
double setpointCorF = (double)values[SetpointAddress] * 0.1;
|
|
temperatureSetpoint = isFahrenheit ? Units.ConvertFrom(Unit.F, setpointCorF) : setpointCorF;
|
|
string setpointStr = string.Format(novusCfg.SetpFormat, Units.ConvertTo(novusCfg.SetpUnit, temperatureSetpoint));
|
|
|
|
double temperatureCorF = (double)values[ProcessValueAddress] * 0.1;
|
|
actualTemperature = isFahrenheit ? Units.ConvertFrom(Unit.F, temperatureCorF) : temperatureCorF;
|
|
string temperatureStr = string.Format(novusCfg.MsrdFormat, Units.ConvertTo(novusCfg.MsrdUnit, actualTemperature));
|
|
|
|
novusDataValid = true;
|
|
|
|
log.InfoFormat("[{0}] setpoint = {1} temperature = {2}", Name, temperatureSetpoint, actualTemperature);
|
|
log.InfoFormat("[{0}] s1=0x{1} s2=0x{2} s3=0x{3} fw={4} id={5}",
|
|
Name, status1.ToString("X4"), status2.ToString("X4"), status3.ToString("X4"),
|
|
fwVersion, controllerId == 18 ? "N1200HC" : controllerId == 48 ? "N1200" : "unknonw");
|
|
}
|
|
else
|
|
{
|
|
log.InfoFormat("[{0}] received soemthing else", Name);
|
|
}
|
|
}
|
|
}
|
|
else if (novusCfg.DebugLevel == DebugMode.Simulate)
|
|
{
|
|
switch ((StateMachine.Time / 3) % 3)
|
|
{
|
|
case 0: status2 = 0; break;
|
|
case 1: status2 = 1 << 11; break;
|
|
case 2: status2 = 1 << 12; break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>Run this device</summary>
|
|
public void RunDeviceAfter()
|
|
{
|
|
if (DebugLevel != DebugMode.Simulate && DebugLevel != DebugMode.FailureDuringOperation
|
|
&& (StateMachine.Time % 3 == novusCfg.ReservoirNr - 1))
|
|
{
|
|
/// Read setpoint, PV (actual temperature), status1, status2, status3, FW version etc.
|
|
SendValueToNovus(Function.ReadHoldingRegisters, 0, 11);
|
|
}
|
|
}
|
|
|
|
public void StopDevice() { }
|
|
public void StopDevice2() { }
|
|
|
|
|
|
/// <summary>
|
|
/// Set temperature controller setpoint to specified value
|
|
/// </summary>
|
|
/// <param name="temperatureC">Temperature in °C</param>
|
|
/// <returns>true = OK, false = any error</returns>
|
|
public bool SetTemperatureSetpoint(double temperatureC)
|
|
{
|
|
if (temperatureC != 0 && (temperatureC < 5.0 || temperatureC > 95.0))
|
|
{
|
|
return false; /// required temperature out of range
|
|
}
|
|
|
|
if (novusDataValid && (temperatureC == temperatureSetpoint))
|
|
{
|
|
return true; /// already set to the required temperature
|
|
}
|
|
|
|
if (temperatureC != 0) /// temperature==0 disables sending the setpoint
|
|
{
|
|
double reqTemp = isFahrenheit ? Units.ConvertTo(Unit.F, temperatureC) : temperatureC;
|
|
Int16 tempSetpointInt16 = Convert.ToInt16(Math.Round(10 * reqTemp)); /// setpoint in 0.1 °C or °F
|
|
ushort destAddress = SetpointAddress;
|
|
///
|
|
SendValueToNovus(Function.PresetSingleRegister, destAddress, tempSetpointInt16);
|
|
}
|
|
|
|
temperatureSetpoint = temperatureC;
|
|
return true;
|
|
}
|
|
|
|
|
|
void SendValueToNovus(Function function, UInt16 address, Int16 value)
|
|
{
|
|
byte[] msg = new byte[8];
|
|
|
|
msg[0] = (byte)novusCfg.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);
|
|
}
|
|
|
|
|
|
///
|
|
/// Operations, etc.
|
|
///
|
|
public double ReadTemperature()
|
|
{
|
|
return actualTemperature;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Events: SetOpututsDone, Error
|
|
/// </summary>
|
|
/// <returns>SetOutputsOp instance reference casted to IOperaton</returns>
|
|
public IOperation SetTemperatureSetpointOp(double temperature)
|
|
{
|
|
return new SetTemperatureSetpointOp(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);
|
|
}
|
|
|
|
|
|
|
|
///
|
|
/// ISequenceCondition interface implementation (conditions in transition sequences)
|
|
///
|
|
IList<string> sequenceConditionNames;
|
|
IList<IOperation> sequenceConditions;
|
|
|
|
public int ConditionsCount { get { return sequenceConditions != null ? sequenceConditions.Count : 0; } }
|
|
|
|
/// Strings are added to the combo-box for transition sequence condition selection
|
|
public string ConditionName(int i)
|
|
{
|
|
if (sequenceConditionNames != null && i < sequenceConditionNames.Count && i >= 0)
|
|
return sequenceConditionNames[i];
|
|
else
|
|
return string.Empty;
|
|
}
|
|
|
|
/// Operations are executed as a part of a transition sequence
|
|
public IOperation ConditionOp(int i)
|
|
{
|
|
if (sequenceConditions != null && i < sequenceConditions.Count && i >= 0)
|
|
return sequenceConditions[i];
|
|
else
|
|
return null;
|
|
}
|
|
|
|
void ClearConditions()
|
|
{
|
|
sequenceConditionNames = new List<string>();
|
|
sequenceConditions = new List<IOperation>();
|
|
}
|
|
|
|
void AddCondition(string conditionName, bool createOperation, IOperation conditionOperation)
|
|
{
|
|
sequenceConditionNames.Add(conditionName);
|
|
if (createOperation) sequenceConditions.Add(conditionOperation);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a list of conditions
|
|
/// </summary>
|
|
/// <param name="createOps">true = create names and condition operations, false = create names only</param>
|
|
void CreateConditions(bool createOps)
|
|
{
|
|
ClearConditions();
|
|
AddCondition("Set temperature setpoint A", createOps, SetTemperatureSetpointOp(novusCfg.ProcParams.Temp_A));
|
|
AddCondition("Set temperature setpoint B", createOps, SetTemperatureSetpointOp(novusCfg.ProcParams.Temp_B));
|
|
AddCondition("Set temperature setpoint C", createOps, SetTemperatureSetpointOp(novusCfg.ProcParams.Temp_C));
|
|
AddCondition("Set temperature setpoint D", createOps, SetTemperatureSetpointOp(novusCfg.ProcParams.Temp_D));
|
|
AddCondition("Set temperature setpoint E", createOps, SetTemperatureSetpointOp(novusCfg.ProcParams.Temp_E));
|
|
}
|
|
}
|
|
}
|