michal/tbf
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactorization : BenchControl -> Rig

Browse Source
This commit is contained in:
Milan Hanajik
2021-03-05 16:12:24 +01:00
parent 84c8ec26b6
commit 6cf3bd6160
1461 changed files with 6330 additions and 6330 deletions
Download Patch File Download Diff File Expand all files Collapse all files
TBF/Rig/Hart/Common/Enums.cs
+34
View File
@@ -0,0 +1,34 @@
///
/// Copyright (c) 2018 Sensus Slovensko a.s.
///
namespace TBF.Rig.Hart.Common
{
/// <summary>
/// HART start bytes
/// </summary>
public enum Mark : byte
{
ShortFrameMaster2Slave = 0x02,
ShortFrameSlave2Master = 0x06,
LongFrameMaster2Slave = 0x82,
LongFrameSlave2Master = 0x86,
}
/// <summary>
/// HART master addresses
/// </summary>
public enum Master : byte
{
Secondary = 0,
Primary = 0x80,
}
/// <summary>
/// HART commands
/// </summary>
public enum Cmd : byte
{
ReadUniqueID = 0,
ReadPrimaryVar = 1,
}
}
TBF/Rig/Hart/Common/Factory.cs
+27
View File
@@ -0,0 +1,27 @@
///
/// Copyright (c) 2018 Sensus Slovensko a.s.
///
using System.Collections.Generic;
using TBF.Rig.Generic;
namespace TBF.Rig.Hart.Common
{
public class Factory : IComponentFactory
{
public string ClassName { get { return GetType().Namespace.Substring(8); } }
public override string ToString() { return ClassName; }
public void ResetStaticProperties() { Hart.ResetStaticProperties(); }
public IComponent DummyComponent() { return new Hart(); }
public IComponent GetComponent(IComponentCfg cfg, IList<IComponent> components) { return new Hart(cfg); }
public IComponentCfg DefaultConfig() { return new HartCfg(this.GetType().Namespace.Substring(8), this); }
public IComponentCfg CmpntCfgFromCmpntEntity(Config.Entities.Component component)
{
return ComponentCfgBase.CreateFromDbEntity(HartCfg.Serializer, component, this);
}
}
}
TBF/Rig/Hart/Common/Hart.cs
+224
View File
@@ -0,0 +1,224 @@
///
/// Copyright (c) 2018 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO.Ports;
using System.Text;
using System.Threading;
using Common;
using Config.Entities;
using log4net;
using TBF.Rig.Generic;
using TBF.Boxes;
namespace TBF.Rig.Hart.Common
{
/// <summary>
/// Root component for HART communication via a modem connected to a serial port (RS232)
/// </summary>
public class Hart : ComponentBase, IDevice, GenericDevices.IHart
{
private static readonly ILog log = LogManager.GetLogger(typeof(Hart));
public override string ToString() { return string.Format("Modbus({0})", Cfg.ToString(1)); }
private readonly HartCfg hartCfg;
/// Private fields
SerialPort serialPort;
DateTime lastSerialPortWrite;
/// <summary>
/// An array of Queue-s of received telegrams fetched by HART components (as Nivotrack).
/// There is one queue for each device (each slave address).
/// </summary>
public Queue<byte[]>[] ReceivedTelegrams
{
get { return receivedTelegrams; }
}
Queue<byte[]>[] receivedTelegrams;
/// <summary>
/// A Queue of telegrams to send. System prevents sending more then one telegram per 500ms.
/// Function SendMessage( ) either send the telegram immediately using SendMessageNow( ) or
/// inserts the telegram into telegramsToSend queue. The queue is emptied in RunDeviceAfter( ).
/// </summary>
Queue<byte[]> telegramsToSend;
public Hart()
{
}
/// <summary>
/// HART modem connected via serial interface (RS232).
/// Connection settings: 1200 Bd 8-bits odd-parity 1-stop-bit Flow control: none or hardware.
/// </summary>
public Hart(Generic.IComponentCfg cfg)
: base(cfg)
{
receivedTelegrams = new Queue<byte[]>[16]; /// Max. 16 slaves with adresses 0..15
for (int i = 0; i < receivedTelegrams.Length; i++)
{
receivedTelegrams[i] = new Queue<byte[]>();
}
telegramsToSend = new Queue<byte[]>();
serialPort = null;
hartCfg = cfg as HartCfg;
log.Warn(this.ToString());
}
~Hart()
{
}
public void Initialize()
{
if (hartCfg.DebugLevel == DebugMode.Simulate)
{
serialPort = null;
log.FatalFormat("{0} - Device simulated", Name);
return;
}
string comPortName = "COM" + hartCfg.ComPortNr.ToString();
serialPort = new SerialPort(comPortName, hartCfg.BaudRate, hartCfg.Parity, hartCfg.DataBits, hartCfg.StopBits);
serialPort.Handshake = hartCfg.Handshake;
serialPort.Open();
log.FatalFormat("{0} - Device successfully initialized", Name);
}
public void RunDeviceBefore()
{
if (serialPort != null)
{
ParseReceivedData();
}
}
public void RunDeviceAfter()
{
if ((serialPort != null) && (telegramsToSend.Count > 0) && (DateTime.Now - lastSerialPortWrite) > new TimeSpan(0, 0, 0, 0, 500))
{
SendMessageNow(telegramsToSend.Dequeue());
}
}
public void StopDevice()
{
if (serialPort != null)
{
serialPort.Close();
serialPort = null;
}
}
public void StopDevice2() { }
public void SendMessageNow(byte[] message)
{
serialPort.Write(message, 0, message.Length);
lastSerialPortWrite = DateTime.Now;
string s = Telegram.LogTelegram(string.Format("{0} - Sending message ", Name), message);
Debug.WriteLine(s);
log.Debug(s);
}
/// <summary>
/// Send an arbitrary modbus message.
/// When the message length is N, however only bytes 1..N-2 have to be set.
/// The last two message bytes (CRC) may be uninitialized or zero.
/// They are calculated inside this function as required by Modbus specification.
/// </summary>
/// <param name="message">Message incl. a reserved checksum byte, checksum does not have to be set</param>
public void SendMessage(int preambLen, byte[] message)
{
if (serialPort == null) return;
Telegram.UpdateTelegramChecksum(message);
byte[] preambAndMessage = new byte[message.Length + preambLen];
for (int i = 0; i < preambLen; i++) preambAndMessage[i] = (byte)0xFF;
for (int i = preambLen; i < preambLen + message.Length; i++) preambAndMessage[i] = message[i - preambLen];
if ((DateTime.Now - lastSerialPortWrite) > new TimeSpan(0, 0, 0, 0, 500))
{
/// More then 100 ms since last 'send' --> do not enqueue the message
SendMessageNow(preambAndMessage);
}
else
{
telegramsToSend.Enqueue(preambAndMessage);
string s = Telegram.LogTelegram(string.Format("{0} - Enqueueing message ", Name), message);
Debug.WriteLine(s);
log.Debug(s);
}
}
void ParseReceivedData()
{
int nrBytes = serialPort.BytesToRead;
if (nrBytes > 0)
{
/// Read available data
byte[] buf = new byte[nrBytes];
serialPort.Read(buf, 0, nrBytes);
/// Determine count of leading FF-s
int preambLen = 0;
for (int i = 0; i < nrBytes; i++)
{
if (buf[i] != (byte)0xFF) break;
preambLen++;
}
int telegramLen = nrBytes - preambLen;
/// Check a telegram length, a checksum, a start byte (S -> M) and a master address (primary)
if (preambLen < 3 ||
telegramLen < 4 ||
!Telegram.VerifyTelegramChecksum(preambLen, buf) ||
((buf[preambLen] != (byte)Mark.ShortFrameSlave2Master) && (buf[preambLen] != (byte)Mark.LongFrameSlave2Master)) ||
((buf[preambLen + 1] & 0x80) != (byte)Master.Primary))
{
string s = Telegram.LogTelegram(string.Format("{0} - Invalid data received ", Name), buf);
Debug.WriteLine(s);
log.Debug(s);
return;
}
/// Strip the preamble
byte[] data = new byte[telegramLen];
for (int i = preambLen; i < nrBytes; i++) data[i - preambLen] = buf[i];
bool isShortFrame = (data[0] == 0x06);
if (isShortFrame)
{
int address = data[1] & 0x0F;
receivedTelegrams[address].Enqueue(data);
string s = string.Format("{0} - {1} address={2} preambLen={3} count={4}", Name, Telegram.LogTelegram("Valid telegram received: ", data), address, preambLen, receivedTelegrams[address].Count);
Debug.WriteLine(s);
log.Debug(s);
}
else
{
/// TODO
string s = Telegram.LogTelegram(string.Format("{0} - Telegram with long address received ", Name), buf);
Debug.WriteLine(s);
log.Debug(s);
}
}
}
}
}
TBF/Rig/Hart/Common/HartCfg.cs
+248
View File
@@ -0,0 +1,248 @@
///
/// Copyright (c) 2018 Sensus Slovensko a.s.
///
using System.IO;
using System.Collections.Generic;
using System.IO.Ports;
using System.Xml.Serialization;
using Config.Entities;
using TBF.Rig.Generic;
namespace TBF.Rig.Hart.Common
{
public class HartCfg : ComponentCfgBase, Generic.IComponentCfg, Config.Entities.IParamsProvider
{
public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(HartCfg) })[0];
public override XmlSerializer GetSerializer() { return Serializer; }
static readonly int[] AllBaudRates = new int[] { 300, 600, 1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200 };
static readonly Parity[] AllParities = new Parity[] { Parity.None, Parity.Even, Parity.Odd };
static readonly int[] AllDataBits = new int[] { 7, 8 };
static readonly StopBits[] AllStopBits = new StopBits[] { StopBits.None, StopBits.One, StopBits.OnePointFive, StopBits.Two };
static readonly Handshake[] AllHandshakes = new Handshake[] { Handshake.None, Handshake.XOnXOff, Handshake.RequestToSend, Handshake.RequestToSendXOnXOff };
public IComponentCfgCtrl GetControl(IList<Config.Entities.Component> cmpntEntities)
{
return new Configs.ParamsProvider.ComponentCfgCtrl(this, null);
}
///
/// Serialized parameters
///
public int ComPortNr;
public int BaudRate;
public int DataBits;
public Parity Parity;
public StopBits StopBits;
public Handshake Handshake;
/// Private parameterless constructor invoked by all other (public) constructors
HartCfg()
{
}
public HartCfg(string name, IComponentFactory factory)
: this()
{
Name = name;
Factory = factory;
ParentName = string.Empty;
InitializeAll();
}
public string ComponentName { get { return Name; } }
public void InitializeAll()
{
ComPortNr = 3;
BaudRate = 1200;
DataBits = 8;
Parity = System.IO.Ports.Parity.Odd;
StopBits = System.IO.Ports.StopBits.One;
Handshake = System.IO.Ports.Handshake.None;
}
string[] paramNames = new string[]
{
"Com port number",
"Baud rate",
"Data bits",
"Parity",
"Stop bits",
"Handshake"
};
public string ParamName(int i) { return paramNames[i]; }
public int ParamsCount() { return paramNames.Length; }
public ICollection<string> ParamValues(int i)
{
IList<string> list = new List<string>();
switch (i)
{
case 1: foreach (var v in AllBaudRates) list.Add(v.ToString()); break;
case 2: foreach (var v in AllDataBits) list.Add(v.ToString()); break;
case 3: foreach (var v in AllParities) list.Add(v.ToString()); break;
case 4: foreach (var v in AllStopBits) list.Add(v.ToString()); break;
case 5: foreach (var v in AllHandshakes) list.Add(v.ToString()); break;
default: return null;
}
return list;
}
public string ToString(int i)
{
if (i == -1)
{
return string.Format("Com{0}, {1}Bd, {2}-bits, parity={3}, stopBits={4}, {5}",
ComPortNr, BaudRate, DataBits, Parity, StopBits, Handshake);
}
switch (i)
{
case 0: return ComPortNr.ToString();
case 1: return BaudRate.ToString();
case 2: return DataBits.ToString();
case 3: return Parity.ToString();
case 4: return StopBits.ToString();
case 5: return Handshake.ToString();
default: return string.Empty;
}
}
public CfgUpdateFlags UpdateParam(int i, string strValue)
{
switch (i)
{
case 0:
if (ComPortNr != int.Parse(strValue))
{
ComPortNr = int.Parse(strValue);
return CfgUpdateFlags.RestartRqrd;
}
else
{
return CfgUpdateFlags.None;
}
case 1:
foreach (var v in AllBaudRates)
{
if ((strValue == v.ToString()) && (BaudRate != v))
{
BaudRate = v;
return CfgUpdateFlags.RestartRqrd;
}
}
return CfgUpdateFlags.None;
case 2:
foreach (var v in AllDataBits)
{
if ((strValue == v.ToString()) && (DataBits != v))
{
DataBits = v;
return CfgUpdateFlags.RestartRqrd;
}
}
return CfgUpdateFlags.None;
case 3:
foreach (var v in AllParities)
{
if ((strValue == v.ToString()) && (Parity != v))
{
Parity = v;
return CfgUpdateFlags.RestartRqrd;
}
}
return CfgUpdateFlags.None;
case 4:
foreach (var v in AllStopBits)
{
if ((strValue == v.ToString()) && (StopBits != v))
{
StopBits = v;
return CfgUpdateFlags.RestartRqrd;
}
}
return CfgUpdateFlags.None;
case 5:
foreach (var v in AllHandshakes)
{
if ((strValue == v.ToString()) && (Handshake != v))
{
Handshake = v;
return CfgUpdateFlags.RestartRqrd;
}
}
return CfgUpdateFlags.None;
default:
return CfgUpdateFlags.None;
}
}
public bool ValidateParam(int i, string strValue, out string message)
{
message = string.Empty;
switch (i)
{
case 0:
int comPortNr;
if (int.TryParse(strValue, out comPortNr) && comPortNr > 0 && comPortNr <= 999) return true;
break;
case 1:
foreach (var v in AllBaudRates) if (strValue == v.ToString()) return true;
break;
case 2:
foreach (var v in AllDataBits) if (strValue == v.ToString()) return true;
break;
case 3:
foreach (var v in AllParities) if (strValue == v.ToString()) return true;
break;
case 4:
foreach (var v in AllStopBits) if (strValue == v.ToString()) return true;
break;
case 5:
foreach (var v in AllHandshakes) if (strValue == v.ToString()) return true;
break;
default:
message = "Invalid index";
return false;
}
message = ParamName(i) + " is invalid";
return false;
}
void CopyContentTo(HartCfg prms)
{
prms.ParentName = this.ParentName;
prms.ComPortNr = this.ComPortNr;
prms.BaudRate = this.BaudRate;
prms.DataBits = this.DataBits;
prms.Parity = this.Parity;
prms.StopBits = this.StopBits;
prms.Handshake = this.Handshake;
}
public Config.Entities.IParamsProvider Clone()
{
HartCfg pars = new HartCfg();
CopyContentTo(pars);
return pars;
}
public bool UpdateEmbeddedDbEntity()
{
return true; /// =OK, do nothing
}
}
}