tbf/TestBenchFramework/BenchControl/Modbus/Common/Modbus.cs

///
/// Copyright (c) 2015-2017 Sensus Metering Systems
///
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO.Ports;
using System.Text;
using System.Threading;
using Config.Entities;
using log4net;
using TBF.BenchControl.Generic;
using TBF.Boxes;

namespace TBF.BenchControl.Modbus.Common
{
    /// <summary>
	/// Root component for Modbus communication via serial port (RS485)
	/// </summary>
	public class Modbus : ComponentBase, IDevice, GenericDevices.IModbus
    {
		private static readonly ILog log = LogManager.GetLogger(typeof(Modbus));
		public override string ToString() { return string.Format("Modbus({0})", Cfg.ToString(1)); }

		private readonly ModbusCfg modbusCommonCfg;

		/// Private fields
		SerialPort serialPort;

		public Queue<byte[]>[] ReceivedTelegrams
		{
			get { return receivedTelegrams; }
		}
		Queue<byte[]>[] receivedTelegrams;

		public Modbus()
		{
		}

		/// <summary>
		/// Ambient temperature / humidity / pressure meter 'Greco' connected via serial interface (RS232)
		/// Connection settings: 19200 Bd 8-bits No-parity 1-stop-bit Flow control: none or hardware.
		/// </summary>
		public Modbus(Generic.IComponentCfg cfg)
            : base(cfg)
        {
			receivedTelegrams = new Queue<byte[]>[256];
			for (int i = 0; i < receivedTelegrams.Length; i++)
			{
				receivedTelegrams[i] = new Queue<byte[]>();
			}

			serialPort = null;
			modbusCommonCfg = cfg as ModbusCfg;
			log.Debug(this.ToString());
		}

		~Modbus()
		{
		}

		public void Initialize()
		{
			if (modbusCommonCfg.DebugLevel == DebugMode.Simulate)
			{
				serialPort = null;
				log.FatalFormat("Simulated device {0}", ToString());
				return;
			}

			string comPortName = "COM" + modbusCommonCfg.ComPortNr.ToString();
			serialPort = new SerialPort(comPortName, modbusCommonCfg.BaudRate, modbusCommonCfg.Parity, modbusCommonCfg.DataBits, modbusCommonCfg.StopBits);
			serialPort.Handshake = modbusCommonCfg.Handshake;
			serialPort.Open();

			//stopWorkerThread = false;
			//workerThread = new Thread(Worker);
			//workerThread.Start();

			log.FatalFormat("Successfully initialized device {0}", ToString());
		}


		/// <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 CRC fields, CRC bytes dont have to be set</param>
		public void SendMessage(byte[] message)
		{
			if (serialPort == null) return;

			Telegram.UpdateTelegramCRC(message);

			serialPort.Write(message, 0, message.Length);

			Debug.WriteLine(Telegram.LogTelegram("Sending message ", message));
			log.Debug(Telegram.LogTelegram("Sending message ", message));
		}


		/// <summary>
		/// Send a structured modbus message.
		/// </summary>
		/// <param name="modbusAddress">Device address (1..255) or 0 = broadcast</param>
		/// <param name="function">Function (0..127)</param>
		/// <param name="dataAddress">Address of data to be transferred (0..65535)</param>
		/// <param name="dataCount">Count of data bytes to be transferred (0..65535)</param>
		public void SendMessage(byte modbusAddress, byte function, ushort dataAddress, ushort dataCount)
		{
			if (serialPort == null) return;

			byte[] message = new byte[8]
			{
				modbusAddress,
				function,
				(byte)(dataAddress / 256),
				(byte)(dataAddress % 256),
				(byte)(dataCount / 256),
				(byte)(dataCount % 256),
				0,
				0,
			};
			Telegram.UpdateTelegramCRC(message);

			serialPort.Write(message, 0, message.Length);

			Debug.WriteLine(Telegram.LogTelegram("Sending message ", message));
			log.Debug(Telegram.LogTelegram("Sending message ", message));
		}


        /// <summary>Run this device</summary>
        public void RunDeviceBefore()
        {
			if (serialPort == null) return;

			int nrBytes = serialPort.BytesToRead;
			if (nrBytes > 0)
			{
				byte[] buffer = new byte[nrBytes];
				serialPort.Read(buffer, 0, nrBytes);
				string s = Telegram.LogTelegram("Received: ", buffer);
				Debug.WriteLine(s);

				if (nrBytes >=3)
				{
					int deviceAddress = buffer[0];
					int function = buffer[1];
					int bytesCount = buffer[2];
					if (nrBytes == bytesCount + 5 && Telegram.VerifyTelegramCRC(buffer))
					{
						receivedTelegrams[deviceAddress].Enqueue(buffer);
						Debug.WriteLine("Valid telegram received: ReceivedTelegrams[{0}].Count = {1}", deviceAddress, receivedTelegrams[deviceAddress].Count);
					}
				}
			}
		}

        /// <summary>Run this device</summary>
        public void RunDeviceAfter()
        {
		}

        /// <summary>Stop this device</summary>
        public void StopDevice()
        {
			if (serialPort != null)
			{
				//stopWorkerThread = true;
				//workerThread.Join(2000);
				serialPort.Close();
				serialPort = null;
			}
		}
	}
}