parkMonitor_V2.0/PLCLinker/newPLCS7/PLCS7.cs

using snap7Enc;
using snap7Enc.Types;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Timers;

namespace PLCS7
{
    public interface IPLCS7
    {
        bool PLCConnect();
        void PLCDisconnect();
        bool WriteToPLC(object abstractPLCMsg, PLCDataType whoami);
        List<object> ReadFromPLC(PLCDataType whichToRead, int index);
    }
    public enum PLCDataType
    {
        terminal,
        central,
        parkingSpace,
        errorInfo,
    }
    public abstract class AbstractPLCLinker : IPLCS7
    {
        protected const int mainBlockOffset = 52;
        protected const int parkingSpaceOffset = 22;
        protected const int terminalLength = 50;
        protected const int parkingSpaceLength = 56;
        /// <summary>
        /// PLC 连接状态flag
        /// </summary>
        public bool isConnected = false;
        /// <summary>
        /// plc中cpu类型
        /// </summary>
        protected CpuType cpu;
        /// <summary>
        /// PLC的IP地址
        /// </summary>
        protected string ip;
        /// <summary>
        /// PLC的端口号
        /// </summary>
        protected Int16 rack;
        /// <summary>
        /// 工作站号
        /// </summary>
        protected Int16 slot;
        /// <summary>
        /// 终端DB块iD
        /// </summary>
        protected int terminalDB;
        /// <summary>
        /// 中心DB块iD
        /// </summary>
        protected int centralDB;
        /// <summary>
        /// 车位DB块ID
        /// </summary>
        protected int parkingSpaceDB;
        /// <summary>
        /// 错误信息提示DB块ID
        /// </summary>
        protected int errorInfoDB;
        /// <summary>
        /// 终端个数
        /// </summary>
        protected int terminalCount;
        /// <summary>
        /// 停车位个数
        /// </summary>
        protected int parkingSpaceCount;
        /// <summary>
        /// PLC S7连接对象
        /// </summary>
        protected static Plc plc = null;
        /// <summary>
        /// 用于将写PLC指令排队的阻塞队列
        /// </summary>
        protected static BlockingCollection<MsgNodeToWrite> writingBlockingCollection = new BlockingCollection<MsgNodeToWrite>();
        /// <summary>
        /// 写线程，控制PLC写入频率
        /// </summary>
        protected static Thread writeThread;
        /// <summary>
        /// 系统关闭
        /// </summary>
        protected bool closed;
        /// <summary>
        /// 读写锁
        /// </summary>
        protected static object readWriteLock = new object();

        /// <summary>
        /// 连接
        /// </summary>
        /// <returns></returns>
        public abstract bool PLCConnect();
        /// <summary>
        /// 断开连接
        /// </summary>
        public abstract void PLCDisconnect();
        /// <summary>
        /// 读PLC
        /// </summary>
        /// <param name="whichToRead"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        public abstract List<object> ReadFromPLC(PLCDataType whichToRead, int index);
        /// <summary>
        /// 写PLC
        /// </summary>
        /// <param name="abstractPLCMsg"></param>
        /// <param name="whoami"></param>
        /// <returns></returns>
        public abstract bool WriteToPLC(object abstractPLCMsg, PLCDataType whoami);
    }

    public class PLCLinker : AbstractPLCLinker
    {
        ///// <summary>
        ///// PLC刷新频率，来自于配置文件
        ///// </summary>
        //private int PLC_refresh_interval;
        ///// <summary>
        ///// 无法获取配置文件时使用的PLC刷新频率
        ///// </summary>
        //private const short PLC_TIME_SCALE = 200;

        //************************************** 方法区 *************************************
        public void test()
        {
            Random rnd = new Random();
            Task t = Task.Factory.StartNew(() =>
            {
                while (true)
                {
                    TerminalStru terminal1 = new TerminalStru();
                    terminal1 = (TerminalStru)ReadStruFromPLC(terminal1, 27, 0);
                    Console.WriteLine(terminal1.ToString());
                    Thread.Sleep(200);
                    terminal1.terminalStatus = (short)rnd.Next(1, 6);
                    terminal1.licenseCodeA = rnd.Next(3000, 9999);
                    terminal1.receiptNum = rnd.Next(3000, 9999);
                    terminal1.licVerification = (short)rnd.Next(1, 555);
                    WriteStruToPLC(terminal1, 27, 0);
                    //List<byte> bList = Struct.ToBytes(terminal1).ToList();
                    //WriteMultipleBytes(27, bList, 0);

                    ////203 chars
                    //string str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccc";
                    ////pl.WriteMultipleBytes(1, (Encoding.ASCII.GetBytes(str)).ToList());
                    //byte[] bytes = pl.ReadMultipleBytes(27, 50).ToArray();
                    //string str2 = Encoding.ASCII.GetString(bytes);
                    //Console.WriteLine(str2);
                    //if (str == str2)
                    //{
                    //    Console.WriteLine("equals");
                    //}
                    //else
                    //{
                    //    Console.WriteLine("error, unequal");
                    //}

                    Thread.Sleep(2000);
                }
            });
            t.Wait();
        }
        /// <summary>
        /// PLCLinker构造函数
        /// </summary>
        /// <param name="cpu"></param>
        /// <param name="ip"></param>
        /// <param name="rack"></param>
        /// <param name="slot"></param>
        /// <param name="terminalDB"></param>
        /// <param name="centralDB"></param>
        /// <param name="parkingSpaceDB"></param>
        public PLCLinker(CpuType cpu, string ip, short rack, short slot, int terminalDB, int centralDB, int parkingSpaceDB, int terminalCount, int parkingSpaceCount)
        {
            this.cpu = cpu;
            this.ip = ip;
            this.rack = rack;
            this.slot = slot;
            this.terminalDB = terminalDB;
            this.centralDB = centralDB;
            this.parkingSpaceDB = parkingSpaceDB;
            this.terminalCount = terminalCount;
            this.parkingSpaceCount = parkingSpaceCount;
            isConnected = PLCConnect();
        }
        /// <summary>
        /// 带错误提示块的构造函数
        /// </summary>
        /// <param name="cpu"></param>
        /// <param name="ip"></param>
        /// <param name="rack"></param>
        /// <param name="slot"></param>
        /// <param name="terminalDB"></param>
        /// <param name="centralDB"></param>
        /// <param name="parkingSpaceDB"></param>
        /// <param name="errorInfoDB"></param>
        /// <param name="terminalCount"></param>
        /// <param name="parkingSpaceCount"></param>
        public PLCLinker(CpuType cpu, string ip, short rack, short slot, int terminalDB, int centralDB, int parkingSpaceDB, int errorInfoDB, int terminalCount, int parkingSpaceCount):this(cpu,ip,rack,slot,terminalDB,centralDB,parkingSpaceDB,terminalCount,parkingSpaceCount)
        {
            this.errorInfoDB = errorInfoDB;
            isConnected = PLCConnect();
        }
        /// <summary>
        /// 读取指定数据块中多个字节
        /// </summary>
        /// <param name="db"></param>
        /// <param name="length"></param>
        /// <param name="startAddr"></param>
        /// <returns></returns>
        private List<byte> ReadMultipleBytes(int db, int length, int startAddr = 0)
        {
            List<byte> resultBytes = new List<byte>();
            int index = startAddr;
            int remains = length;
            while (remains > 0)
            {
                int maxToRead = Math.Min(remains, 200);
                try
                {
                    byte[] temp = plc.ReadBytes(DataType.DataBlock, db, index, maxToRead);
                    if (temp == null)
                        return new List<byte>();
                    resultBytes.AddRange(temp);
                    remains -= maxToRead;
                    index += maxToRead;
                }
                catch { }
            }
            return resultBytes;
        }
        /// <summary>
        /// 写入指定数据块中多个字节
        /// </summary>
        /// <param name="db"></param>
        /// <param name="bytesToWrite"></param>
        /// <param name="startAddr"></param>
        /// <returns></returns>
        private ErrorCode WriteMultipleBytes(int db, List<byte> bytesToWrite, int startAddr = 0)
        {
            int index = startAddr;
            int remains = bytesToWrite.Count();
            try
            {
                while (remains > 0)
                {
                    int maxToWrite = Math.Min(remains, 200);
                    ErrorCode ec = plc.WriteBytes(DataType.DataBlock, db, index, bytesToWrite.GetRange(index, maxToWrite).ToArray());
                    index += maxToWrite;
                    remains -= maxToWrite;
                    if (!ec.Equals(ErrorCode.NoError)) { return ec; }
                }
            }
            catch (Exception e) { Console.WriteLine(e.Message); }
            return ErrorCode.NoError;
        }
        /// <summary>
        /// 从PLC中读取结构体
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="db"></param>
        /// <param name="startAddr"></param>
        /// <returns></returns>
        private object ReadStruFromPLC(object obj, int db, int startAddr = 0)
        {
            Type structType = obj.GetType();
            object returnedObj;
            try
            {
                //returnedObj = plc.ReadStruct(structType, db, startAddr);
                int numBytes = Struct.GetStructSize(structType);
                var resultBytes = plc.ReadBytes(DataType.DataBlock, db, startAddr, numBytes);
                returnedObj = Struct.FromBytes(structType, resultBytes);
                if (returnedObj != null) { return returnedObj; }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            return null;
            //Console.WriteLine(ts.ToString());
        }
        /// <summary>
        /// 向PLC中写入结构体
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="db"></param>
        /// <param name="startAddr"></param>
        private ErrorCode WriteStruToPLC(object obj, int db, int startAddr = 0)
        {
            Console.WriteLine("write to PLC");
            ErrorCode ec = ErrorCode.NoError;
            try
            {
                //ec = plc.WriteStruct(obj, 22, startAddr);
                List<byte> bList = Struct.ToBytes(obj).ToList();
                ec = WriteMultipleBytes(db, bList, startAddr);
            }
            catch (Exception e) { Console.WriteLine(ec.ToString() + "," + e.Message); }
            return ec;
        }
        private short BytesRevert(short num)
        {
            byte[] temp = BitConverter.GetBytes(num);
            Array.Reverse(temp);
            return BitConverter.ToInt16(temp, 0);
        }
        private int BytesRevert(int num)
        {
            byte[] temp = BitConverter.GetBytes(num);
            Array.Reverse(temp);
            return BitConverter.ToInt32(temp, 0);
        }
        /// <summary>
        /// 从阻塞队列获取需写入PLC数据并写入PLC，时间间隔在线程中控制
        /// </summary>
        /// <returns></returns>
        private bool WriteAccordingly()
        {
            MsgNodeToWrite msg = null;
            try
            {
                msg = writingBlockingCollection.Take();
                //Console.WriteLine("取出后，" + writingBlockingCollection.Count);
            }
            catch (Exception ex) { Console.WriteLine("获取PLC写对象异常，" + ex.Message); }
            if (msg == null || msg.abstractPLCMsg == null)
            {
                Console.WriteLine((msg == null) + "," + (msg.abstractPLCMsg == null));
                return false;
            }
            //更新设备状态
            isConnected = plc.IsConnected;
            if (isConnected)
            {
                lock (readWriteLock)
                {
                    if (msg.abstractPLCMsg.GetType().Equals(typeof(TerminalStru)))
                    {
                        TerminalStru ts = (TerminalStru)msg.abstractPLCMsg;
                        if (ts.terminalID <= 0 || ts.terminalID > terminalCount) { Console.WriteLine("终端id:" + ts.terminalID); return false; }
                        int offset = terminalLength * (ts.terminalID - 1);
                        if (msg.whoami.Equals(PLCDataType.central))
                        {
                            if (ts.paymentStatus != (short)-1) { plc.WriteBytes(DataType.DataBlock, terminalDB, 28 + offset, BitConverter.GetBytes(BytesRevert(ts.paymentStatus))); }
                            if (ts.licVerification != (short)-1) { plc.WriteBytes(DataType.DataBlock, terminalDB, 30 + offset, BitConverter.GetBytes(BytesRevert(ts.licVerification))); }
                            if (ts.parkingFee != (short)-1) { plc.WriteBytes(DataType.DataBlock, terminalDB, 32 + offset, BitConverter.GetBytes(BytesRevert(ts.parkingFee))); }
                            if (ts.userType != (short)-1) { plc.WriteBytes(DataType.DataBlock, terminalDB, 34 + offset, BitConverter.GetBytes(BytesRevert(ts.userType))); }
                        }
                        else if (msg.whoami.Equals(PLCDataType.terminal))
                        {
                            //if (ts.terminalStatus != (short)-1) { plc.WriteBytes(DataType.DataBlock, terminalDB, 2 + offset, BitConverter.GetBytes(BytesRevert(ts.terminalStatus))); }
                            if (ts.paymentStatus != (short)-1) { plc.WriteBytes(DataType.DataBlock, terminalDB, 28 + offset, BitConverter.GetBytes(BytesRevert(ts.paymentStatus))); }
                            if (ts.btnStatus != (short)-1) { plc.WriteBytes(DataType.DataBlock, terminalDB, 4 + offset, BitConverter.GetBytes(BytesRevert(ts.btnStatus))); }
                            if (ts.cmd != (short)-1) { plc.WriteBytes(DataType.DataBlock, terminalDB, 6 + offset, BitConverter.GetBytes(BytesRevert(ts.cmd))); }
                            if (ts.licenseCodeA != -1) { plc.WriteBytes(DataType.DataBlock, terminalDB, 8 + offset, BitConverter.GetBytes(BytesRevert(ts.licenseCodeA))); }
                            if (ts.licenseCodeB != -1) { plc.WriteBytes(DataType.DataBlock, terminalDB, 12 + offset, BitConverter.GetBytes(BytesRevert(ts.licenseCodeB))); }
                            if (ts.licenseCodeC != -1) { plc.WriteBytes(DataType.DataBlock, terminalDB, 16 + offset, BitConverter.GetBytes(BytesRevert(ts.licenseCodeC))); }
                            if (ts.licenseCodeD != -1) { plc.WriteBytes(DataType.DataBlock, terminalDB, 20 + offset, BitConverter.GetBytes(BytesRevert(ts.licenseCodeD))); }
                            if (ts.receiptNum != -1) { plc.WriteBytes(DataType.DataBlock, terminalDB, 24 + offset, BitConverter.GetBytes(BytesRevert(ts.receiptNum))); }
                            if (ts.termHeartbeat != 0) { plc.WriteBytes(DataType.DataBlock, terminalDB, 48 + offset, BitConverter.GetBytes(BytesRevert(ts.termHeartbeat))); }
                        }
                    }
                    else if (msg.abstractPLCMsg.GetType().Equals(typeof(MainBlockStru)) && msg.whoami.Equals(PLCDataType.central))
                    {
                        //只允许中控写入
                        MainBlockStru mbs = (MainBlockStru)msg.abstractPLCMsg;
                        //byte[] temp = BitConverter.GetBytes(BytesRevert(mbs.licenseReceived));
                        if (mbs.centralHearbeat != (short)-1) { plc.WriteBytes(DataType.DataBlock, centralDB, mainBlockOffset + 8, BitConverter.GetBytes(BytesRevert(mbs.centralHearbeat))); }
                        if (mbs.licenseReceived != (short)-1) { plc.WriteBytes(DataType.DataBlock, centralDB, mainBlockOffset, BitConverter.GetBytes(BytesRevert(mbs.licenseReceived))); }
                        if (mbs.bookParkCmd != (short)-1) { plc.WriteBytes(DataType.DataBlock, centralDB, mainBlockOffset - 4, BitConverter.GetBytes(BytesRevert(mbs.bookParkCmd))); }
                        if (mbs.bookFetchCmd != (short)-1) { plc.WriteBytes(DataType.DataBlock, centralDB, mainBlockOffset - 2, BitConverter.GetBytes(BytesRevert(mbs.bookFetchCmd))); }
                        if (mbs.processCompleted != (short)-1) { plc.WriteBytes(DataType.DataBlock, centralDB, 16, BitConverter.GetBytes(BytesRevert(mbs.processCompleted))); }
                        //ErrorCode ec = plc.WriteBytes(DataType.DataBlock, centralDB, mainBlockOffset, temp);
                        //if (!ec.Equals(ErrorCode.NoError)) { return false; }
                    }
                    else if (msg.abstractPLCMsg.GetType().Equals(typeof(ParkingSpaceStru)) && msg.whoami.Equals(PLCDataType.central))
                    {
                        //只允许中控写入，中控只允许写车位状态
                        ParkingSpaceStru pss = (ParkingSpaceStru)msg.abstractPLCMsg;
                        int offset = parkingSpaceLength * (pss.parkingSpace - 1) + parkingSpaceOffset;
                        byte[] temp = BitConverter.GetBytes(BytesRevert(pss.spaceStatus));
                        ErrorCode ec = plc.WriteBytes(DataType.DataBlock, parkingSpaceDB, offset, temp);
                        if (!ec.Equals(ErrorCode.NoError)) { return false; }
                    }
                    else { Console.WriteLine(msg.whoami); return false; }
                }
            }
            else { Console.WriteLine("掉线"); return false; }
            return true;
        }

        /// <summary>
        /// 读取PLC数据块
        /// </summary>
        /// <param name="whichToRead"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        public override List<object> ReadFromPLC(PLCDataType whichToRead, int index)
        {
            //更新设备状态
            isConnected = plc.IsConnected;
            List<object> result = new List<object>();
            if (!isConnected)
            {
                PLCConnect();
            }
            if (isConnected)
            {
                lock (readWriteLock)
                {
                    switch (whichToRead)
                    {
                        case PLCDataType.central:
                            object obj = ReadStruFromPLC(new MainBlockStru(), centralDB);
                            if (obj != null) { result.Add(obj); }
                            break;
                        case PLCDataType.terminal:
                            TerminalStru ts = new TerminalStru();
                            //index 在合理范围读取单一元素，否则全部读取
                            if (index > 0 && index < terminalCount)
                            {
                                obj = ReadStruFromPLC(ts, terminalDB, Struct.GetStructSize(ts.GetType()) * (index - 1));
                                if (obj != null) { result.Add(obj); }
                            }
                            else
                            {
                                for (int i = 0; i < terminalCount; i++)
                                {
                                    obj = ReadStruFromPLC(ts, terminalDB, Struct.GetStructSize(ts.GetType()) * i);
                                    if (obj != null) { result.Add(obj); }
                                }
                            }
                            break;
                        case PLCDataType.parkingSpace:
                            ParkingSpaceStru pss = new ParkingSpaceStru();
                            //index 在合理范围读取单一元素，否则全部读取
                            if (index > 0 && index < parkingSpaceCount)
                            {
                                obj = ReadStruFromPLC(pss, parkingSpaceDB, Struct.GetStructSize(pss.GetType()) * (index - 1));
                                if (obj != null) { result.Add(obj); }
                            }
                            else
                            {
                                for (int i = 0; i < parkingSpaceCount; i++)
                                {
                                    obj = ReadStruFromPLC(pss, parkingSpaceDB, Struct.GetStructSize(pss.GetType()) * i);
                                    if (obj != null) { result.Add(obj); }
                                }
                            }
                            break;
                        case PLCDataType.errorInfo:
                            object errorInfo = ReadStruFromPLC(new ErrorInfoStru(), errorInfoDB);
                            if (errorInfo != null) { result.Add(errorInfo); }
                            break;
                        default:
                            Console.WriteLine("wrong type");
                            break;
                    }
                }
            }
            return result;
        }
        /// <summary>
        /// 写入PLC，其中可写入但不需写入字段请赋值为-1
        /// </summary>
        /// <param name="abstractPLCMsg"></param>
        /// <param name="whoami"></param>
        /// <returns></returns>
        public override bool WriteToPLC(object abstractPLCMsg, PLCDataType whoami)
        {
            //更新设备状态
            isConnected = plc.IsConnected;
            if (abstractPLCMsg != null)
            {
                writingBlockingCollection.Add(new MsgNodeToWrite(abstractPLCMsg, whoami));
                //Console.WriteLine("加入后，" + writingBlockingCollection.Count);
                return true;
            }
            else
                return false;
        }
        /// <summary>
        /// 连接PLC
        /// </summary>
        /// <returns></returns>
        public override bool PLCConnect()
        {
            closed = false;
            writeThread = new Thread(() =>
            {
                //Stopwatch stopwatch = new Stopwatch();
                while (!closed)
                {
                    //stopwatch.Restart();
                    bool result = WriteAccordingly();
                    if (!result)
                        Console.WriteLine("写PLC操作异常");
                    Thread.Sleep(20);
                    //stopwatch.Stop();
                    //Console.WriteLine(stopwatch.ElapsedMilliseconds / 1000.0f);
                }
            });
            writeThread.IsBackground = true;
            writeThread.Priority = ThreadPriority.AboveNormal;
            writeThread.Start();

            if (plc == null)
            {
                plc = new Plc(cpu, ip, rack, slot);
            }
            if (plc != null)
            {
                ErrorCode err = plc.Open();
                if (err != ErrorCode.NoError) { Console.WriteLine("connection error"); isConnected = false; }
                else { Console.WriteLine("connected"); isConnected = true; }
            }
            else { isConnected = false; }
            return isConnected;
        }
        /// <summary>
        /// 关闭PLC连接
        /// </summary>
        public override void PLCDisconnect()
        {
            //try
            //{
            //    if (writeThread != null)
            //        writeThread.Abort();
            //}
            //catch (Exception ex) { Console.WriteLine("强制终止写PLC线程，" + ex.Message); }
            closed = true;
            if (plc != null)
            {
                plc.Close();
            }
        }

        /// <summary>
        /// 根据地址偏移量写入PLC
        /// </summary>
        /// <param name="whichToWrite"></param>
        /// <param name="offset"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool WriteAccordingToOffset(PLCDataType whichToWrite, int offset, object value)
        {
            isConnected = plc.IsConnected;
            if (value == null)
                return false;
            if (isConnected)
            {
                ErrorCode ec = ErrorCode.NoError;
                switch (whichToWrite)
                {
                    case PLCDataType.terminal:
                        if (value.GetType().Equals(typeof(int)))
                        {
                            ec = plc.WriteBytes(DataType.DataBlock, terminalDB, offset, BitConverter.GetBytes(BytesRevert((int)value)));
                        }
                        else if (value.GetType().Equals(typeof(short)))
                        {
                            ec = plc.WriteBytes(DataType.DataBlock, terminalDB, offset, BitConverter.GetBytes(BytesRevert((short)value)));
                        }
                        if (ec.Equals(ErrorCode.NoError)) { return true; }
                        else { return false; }
                        break;
                    case PLCDataType.central:
                        if (value.GetType().Equals(typeof(int)))
                        {
                            ec = plc.WriteBytes(DataType.DataBlock, centralDB, offset, BitConverter.GetBytes(BytesRevert((int)value)));
                        }
                        else if (value.GetType().Equals(typeof(short)))
                        {
                            ec = plc.WriteBytes(DataType.DataBlock, centralDB, offset, BitConverter.GetBytes(BytesRevert((short)value)));
                        }
                        if (ec.Equals(ErrorCode.NoError)) { return true; }
                        else { return false; }
                        break;
                    case PLCDataType.parkingSpace:
                        if (value.GetType().Equals(typeof(int)))
                        {
                            ec = plc.WriteBytes(DataType.DataBlock, parkingSpaceDB, offset, BitConverter.GetBytes(BytesRevert((int)value)));
                        }
                        else if (value.GetType().Equals(typeof(short)))
                        {
                            ec = plc.WriteBytes(DataType.DataBlock, parkingSpaceDB, offset, BitConverter.GetBytes(BytesRevert((short)value)));
                        }
                        if (ec.Equals(ErrorCode.NoError)) { return true; }
                        else { return false; }
                        break;
                }
            }
            return false;
        }
    }

    public class MsgNodeToWrite
    {
        public object abstractPLCMsg;
        public PLCDataType whoami;
        public MsgNodeToWrite(object abstractPLCMsg, PLCDataType whoami)
        {
            this.abstractPLCMsg = abstractPLCMsg;
            this.whoami = whoami;
        }
    }
}