MES / haiNeng · Files

using HslCommunication.BasicFramework;
using HslCommunication.Core;
using HslCommunication.Core.Address;
using HslCommunication.Core.IMessage;
using HslCommunication.Core.Net;
using System;
using System.Linq;
using System.Net.Sockets;

namespace HslCommunication.Profinet.Melsec
{
    /// <summary>
    /// 三菱MC协议的虚拟服务器，支持M,X,Y,D,W的数据池读写操作，使用二进制进行读写操作
    /// </summary>
    public class MelsecMcServer : NetworkDataServerBase
    {
        #region Constructor

        /// <summary>
        /// 实例化一个mc协议的服务器
        /// </summary>
        public MelsecMcServer()
        {
            // 共计使用了五个数据池
            xBuffer = new SoftBuffer(DataPoolLength);
            yBuffer = new SoftBuffer(DataPoolLength);
            mBuffer = new SoftBuffer(DataPoolLength);
            dBuffer = new SoftBuffer(DataPoolLength * 2);
            wBuffer = new SoftBuffer(DataPoolLength * 2);

            WordLength = 1;
            ByteTransform = new RegularByteTransform();
        }

        #endregion

        #region NetworkDataServerBase Override

        /// <summary>
        /// 读取自定义的寄存器的值。按照字为单位
        /// </summary>
        /// <param name="address">起始地址，示例："D100"，"M100"</param>
        /// <param name="length">数据长度</param>
        /// <exception cref="IndexOutOfRangeException"></exception>
        /// <returns>byte数组值</returns>
        public override OperateResult<byte[]> Read(string address, ushort length)
        {
            // 分析地址
            OperateResult<McAddressData> analysis = McAddressData.ParseMelsecFrom(address, length);
            if (!analysis.IsSuccess) return OperateResult.CreateFailedResult<byte[]>(analysis);

            if (analysis.Content.McDataType.DataCode == MelsecMcDataType.M.DataCode)
            {
                bool[] buffer = mBuffer.GetBytes(analysis.Content.AddressStart, length * 16).Select(m => m != 0x00).ToArray();
                return OperateResult.CreateSuccessResult(SoftBasic.BoolArrayToByte(buffer));
            }
            else if (analysis.Content.McDataType.DataCode == MelsecMcDataType.X.DataCode)
            {
                bool[] buffer = xBuffer.GetBytes(analysis.Content.AddressStart, length * 16).Select(m => m != 0x00).ToArray();
                return OperateResult.CreateSuccessResult(SoftBasic.BoolArrayToByte(buffer));
            }
            else if (analysis.Content.McDataType.DataCode == MelsecMcDataType.Y.DataCode)
            {
                bool[] buffer = yBuffer.GetBytes(analysis.Content.AddressStart, length * 16).Select(m => m != 0x00).ToArray();
                return OperateResult.CreateSuccessResult(SoftBasic.BoolArrayToByte(buffer));
            }
            else if (analysis.Content.McDataType.DataCode == MelsecMcDataType.D.DataCode)
            {
                return OperateResult.CreateSuccessResult(dBuffer.GetBytes(analysis.Content.AddressStart * 2, length * 2));
            }
            else if (analysis.Content.McDataType.DataCode == MelsecMcDataType.W.DataCode)
            {
                return OperateResult.CreateSuccessResult(wBuffer.GetBytes(analysis.Content.AddressStart * 2, length * 2));
            }
            else
            {
                return new OperateResult<byte[]>(StringResources.Language.NotSupportedDataType);
            }
        }

        /// <summary>
        /// 写入自定义的数据到数据内存中去
        /// </summary>
        /// <param name="address">地址</param>
        /// <param name="value">数据值</param>
        /// <returns>是否写入成功的结果对象</returns>
        public override OperateResult Write(string address, byte[] value)
        {
            // 分析地址
            OperateResult<McAddressData> analysis = McAddressData.ParseMelsecFrom(address, 0);
            if (!analysis.IsSuccess) return OperateResult.CreateFailedResult<byte[]>(analysis);

            if (analysis.Content.McDataType.DataCode == MelsecMcDataType.M.DataCode)
            {
                byte[] buffer = SoftBasic.ByteToBoolArray(value).Select(m => m ? (byte)1 : (byte)0).ToArray();
                mBuffer.SetBytes(buffer, analysis.Content.AddressStart);
                return OperateResult.CreateSuccessResult();
            }
            else if (analysis.Content.McDataType.DataCode == MelsecMcDataType.X.DataCode)
            {
                byte[] buffer = SoftBasic.ByteToBoolArray(value).Select(m => m ? (byte)1 : (byte)0).ToArray();
                xBuffer.SetBytes(buffer, analysis.Content.AddressStart);
                return OperateResult.CreateSuccessResult();
            }
            else if (analysis.Content.McDataType.DataCode == MelsecMcDataType.Y.DataCode)
            {
                byte[] buffer = SoftBasic.ByteToBoolArray(value).Select(m => m ? (byte)1 : (byte)0).ToArray();
                yBuffer.SetBytes(buffer, analysis.Content.AddressStart);
                return OperateResult.CreateSuccessResult();
            }
            else if (analysis.Content.McDataType.DataCode == MelsecMcDataType.D.DataCode)
            {
                dBuffer.SetBytes(value, analysis.Content.AddressStart * 2);
                return OperateResult.CreateSuccessResult();
            }
            else if (analysis.Content.McDataType.DataCode == MelsecMcDataType.W.DataCode)
            {
                wBuffer.SetBytes(value, analysis.Content.AddressStart * 2);
                return OperateResult.CreateSuccessResult();
            }
            else
            {
                return new OperateResult<byte[]>(StringResources.Language.NotSupportedDataType);
            }
        }

        #endregion

        #region Bool Read Write Operate

        /// <summary>
        /// 读取指定地址的bool数据对象
        /// </summary>
        /// <param name="address">西门子的地址信息</param>
        /// <returns>带有成功标志的结果对象</returns>
        public OperateResult<bool> ReadBool(string address)
        {
            OperateResult<bool[]> read = ReadBool(address, 1);
            if (!read.IsSuccess) return OperateResult.CreateFailedResult<bool>(read);

            return OperateResult.CreateSuccessResult(read.Content[0]);
        }

        /// <summary>
        /// 读取指定地址的bool数据对象
        /// </summary>
        /// <param name="address">三菱的地址信息</param>
        /// <param name="length">数组的长度</param>
        /// <returns>带有成功标志的结果对象</returns>
        public OperateResult<bool[]> ReadBool(string address, ushort length)
        {
            // 分析地址
            OperateResult<McAddressData> analysis = McAddressData.ParseMelsecFrom(address, 0);
            if (!analysis.IsSuccess) return OperateResult.CreateFailedResult<bool[]>(analysis);

            if (analysis.Content.McDataType.DataType == 0) return new OperateResult<bool[]>(StringResources.Language.MelsecCurrentTypeNotSupportedWordOperate);

            if (analysis.Content.McDataType.DataCode == MelsecMcDataType.M.DataCode)
            {
                return OperateResult.CreateSuccessResult(mBuffer.GetBytes(analysis.Content.AddressStart, length).Select(m => m != 0x00).ToArray());
            }
            else if (analysis.Content.McDataType.DataCode == MelsecMcDataType.X.DataCode)
            {
                return OperateResult.CreateSuccessResult(xBuffer.GetBytes(analysis.Content.AddressStart, length).Select(m => m != 0x00).ToArray());
            }
            else if (analysis.Content.McDataType.DataCode == MelsecMcDataType.Y.DataCode)
            {
                return OperateResult.CreateSuccessResult(yBuffer.GetBytes(analysis.Content.AddressStart, length).Select(m => m != 0x00).ToArray());
            }
            else
            {
                return new OperateResult<bool[]>(StringResources.Language.NotSupportedDataType);
            }
        }

        /// <summary>
        /// 往指定的地址里写入bool数据对象
        /// </summary>
        /// <param name="address">三菱的地址信息</param>
        /// <param name="value">值</param>
        /// <returns>是否成功的结果</returns>
        public OperateResult Write(string address, bool value)
        {
            return Write(address, new bool[] { value });
        }

        /// <summary>
        /// 往指定的地址里写入bool数组对象
        /// </summary>
        /// <param name="address">三菱的地址信息</param>
        /// <param name="value">值</param>
        /// <returns>是否成功的结果</returns>
        public OperateResult Write(string address, bool[] value)
        {
            // 分析地址
            OperateResult<McAddressData> analysis = McAddressData.ParseMelsecFrom(address, 0);
            if (!analysis.IsSuccess) return OperateResult.CreateFailedResult<bool[]>(analysis);

            if (analysis.Content.McDataType.DataType == 0) return new OperateResult<bool[]>(StringResources.Language.MelsecCurrentTypeNotSupportedWordOperate);

            if (analysis.Content.McDataType.DataCode == MelsecMcDataType.M.DataCode)
            {
                mBuffer.SetBytes(value.Select(m => m ? (byte)1 : (byte)0).ToArray(), analysis.Content.AddressStart);
                return OperateResult.CreateSuccessResult();
            }
            else if (analysis.Content.McDataType.DataCode == MelsecMcDataType.X.DataCode)
            {
                xBuffer.SetBytes(value.Select(m => m ? (byte)1 : (byte)0).ToArray(), analysis.Content.AddressStart);
                return OperateResult.CreateSuccessResult();
            }
            else if (analysis.Content.McDataType.DataCode == MelsecMcDataType.Y.DataCode)
            {
                yBuffer.SetBytes(value.Select(m => m ? (byte)1 : (byte)0).ToArray(), analysis.Content.AddressStart);
                return OperateResult.CreateSuccessResult();
            }
            else
            {
                return new OperateResult<bool[]>(StringResources.Language.NotSupportedDataType);
            }
        }

        #endregion

        #region NetServer Override

        /// <summary>
        /// 当客户端登录后，进行Ip信息的过滤，然后触发本方法，也就是说之后的客户端需要
        /// </summary>
        /// <param name="socket">网络套接字</param>
        /// <param name="endPoint">终端节点</param>
        protected override void ThreadPoolLoginAfterClientCheck(Socket socket, System.Net.IPEndPoint endPoint)
        {
            // 开始接收数据信息
            AppSession appSession = new AppSession();
            appSession.IpEndPoint = endPoint;
            appSession.WorkSocket = socket;
            try
            {
                socket.BeginReceive(new byte[0], 0, 0, SocketFlags.None, new AsyncCallback(SocketAsyncCallBack), appSession);
                AddClient(appSession);
            }
            catch
            {
                socket.Close();
                LogNet?.WriteDebug(ToString(), string.Format(StringResources.Language.ClientOfflineInfo, endPoint));
            }
        }

        private void SocketAsyncCallBack(IAsyncResult ar)
        {
            if (ar.AsyncState is AppSession session)
            {
                try
                {
                    int receiveCount = session.WorkSocket.EndReceive(ar);

                    MelsecQnA3EBinaryMessage mcMessage = new MelsecQnA3EBinaryMessage();
                    OperateResult<byte[]> read1 = ReceiveByMessage(session.WorkSocket, 5000, mcMessage);
                    if (!read1.IsSuccess)
                    {
                        LogNet?.WriteDebug(ToString(), string.Format(StringResources.Language.ClientOfflineInfo, session.IpEndPoint));
                        RemoveClient(session);
                        return;
                    };

                    byte[] back = ReadFromMcCore(read1.Content);
                    if (back != null)
                    {
                        session.WorkSocket.Send(back);
                    }
                    else
                    {
                        session.WorkSocket.Close();
                        RemoveClient(session);
                        return;
                    }

                    RaiseDataReceived(read1.Content);
                    session.WorkSocket.BeginReceive(new byte[0], 0, 0, SocketFlags.None, new AsyncCallback(SocketAsyncCallBack), session);
                }
                catch
                {
                    // 关闭连接，记录日志
                    session.WorkSocket?.Close();
                    LogNet?.WriteDebug(ToString(), string.Format(StringResources.Language.ClientOfflineInfo, session.IpEndPoint));
                    RemoveClient(session);
                    return;
                }
            }
        }

        /// <summary>
        /// 当收到mc协议的报文的时候应该触发的方法，允许继承重写，来实现自定义的返回，或是数据监听。
        /// </summary>
        /// <param name="mcCore">mc报文</param>
        /// <returns>返回的报文信息</returns>
        protected virtual byte[] ReadFromMcCore(byte[] mcCore)
        {
            if (mcCore[11] == 0x01 && mcCore[12] == 0x04)
            {
                // 读数据
                return PackCommand(ReadByCommand(SoftBasic.BytesArrayRemoveBegin(mcCore, 11)));
            }
            else if (mcCore[11] == 0x01 && mcCore[12] == 0x14)
            {
                // 写数据
                return PackCommand(WriteByMessage(SoftBasic.BytesArrayRemoveBegin(mcCore, 11)));
            }
            else
            {
                return null;
            }
        }

        private byte[] PackCommand(byte[] data)
        {
            byte[] back = new byte[11 + data.Length];
            SoftBasic.HexStringToBytes("D0 00 00 FF FF 03 00 00 00 00 00").CopyTo(back, 0);
            if (data.Length > 0) data.CopyTo(back, 11);

            BitConverter.GetBytes((short)(data.Length + 2)).CopyTo(back, 7);
            return back;
        }

        private byte[] ReadByCommand(byte[] command)
        {
            if (command[2] == 0x01)
            {
                // 位读取
                ushort length = ByteTransform.TransUInt16(command, 8);
                int startIndex = (command[6] * 65536 + command[5] * 256 + command[4]);

                if (command[7] == MelsecMcDataType.M.DataCode)
                {
                    byte[] buffer = mBuffer.GetBytes(startIndex, length);
                    return MelsecHelper.TransBoolArrayToByteData(buffer);
                }
                else if (command[7] == MelsecMcDataType.X.DataCode)
                {
                    byte[] buffer = xBuffer.GetBytes(startIndex, length);
                    return MelsecHelper.TransBoolArrayToByteData(buffer);
                }
                else if (command[7] == MelsecMcDataType.Y.DataCode)
                {
                    byte[] buffer = yBuffer.GetBytes(startIndex, length);
                    return MelsecHelper.TransBoolArrayToByteData(buffer);
                }
                else
                {
                    throw new Exception(StringResources.Language.NotSupportedDataType);
                }
            }
            else
            {
                // 字读取
                ushort length = ByteTransform.TransUInt16(command, 8);
                int startIndex = (command[6] * 65536 + command[5] * 256 + command[4]);
                if (command[7] == MelsecMcDataType.M.DataCode)
                {
                    bool[] buffer = mBuffer.GetBytes(startIndex, length * 16).Select(m => m != 0x00).ToArray();
                    return SoftBasic.BoolArrayToByte(buffer);
                }
                else if (command[7] == MelsecMcDataType.X.DataCode)
                {
                    bool[] buffer = xBuffer.GetBytes(startIndex, length * 16).Select(m => m != 0x00).ToArray();
                    return SoftBasic.BoolArrayToByte(buffer);
                }
                else if (command[7] == MelsecMcDataType.Y.DataCode)
                {
                    bool[] buffer = yBuffer.GetBytes(startIndex, length * 16).Select(m => m != 0x00).ToArray();
                    return SoftBasic.BoolArrayToByte(buffer);
                }
                else if (command[7] == MelsecMcDataType.D.DataCode)
                {
                    return dBuffer.GetBytes(startIndex * 2, length * 2);
                }
                else if (command[7] == MelsecMcDataType.W.DataCode)
                {
                    return wBuffer.GetBytes(startIndex * 2, length * 2);
                }
                else
                {
                    throw new Exception(StringResources.Language.NotSupportedDataType);
                }
            }
        }


        private byte[] WriteByMessage(byte[] command)
        {
            if (command[2] == 0x01)
            {
                // 位写入
                ushort length = ByteTransform.TransUInt16(command, 8);
                int startIndex = (command[6] * 65536 + command[5] * 256 + command[4]);

                if (command[7] == MelsecMcDataType.M.DataCode)
                {
                    byte[] buffer = MelsecMcNet.ExtractActualData(SoftBasic.BytesArrayRemoveBegin(command, 10), true).Content;
                    mBuffer.SetBytes(buffer.Take(length).ToArray(), startIndex);
                    return new byte[0];
                }
                else if (command[7] == MelsecMcDataType.X.DataCode)
                {
                    byte[] buffer = MelsecMcNet.ExtractActualData(SoftBasic.BytesArrayRemoveBegin(command, 10), true).Content;
                    xBuffer.SetBytes(buffer.Take(length).ToArray(), startIndex);
                    return new byte[0];
                }
                else if (command[7] == MelsecMcDataType.Y.DataCode)
                {
                    byte[] buffer = MelsecMcNet.ExtractActualData(SoftBasic.BytesArrayRemoveBegin(command, 10), true).Content;
                    yBuffer.SetBytes(buffer.Take(length).ToArray(), startIndex);
                    return new byte[0];
                }
                else
                {
                    throw new Exception(StringResources.Language.NotSupportedDataType);
                }
            }
            else
            {
                // 字写入
                ushort length = ByteTransform.TransUInt16(command, 8);
                int startIndex = (command[6] * 65536 + command[5] * 256 + command[4]);

                if (command[7] == MelsecMcDataType.M.DataCode)
                {
                    byte[] buffer = SoftBasic.ByteToBoolArray(SoftBasic.BytesArrayRemoveBegin(command, 10)).Select(m => m ? (byte)1 : (byte)0).ToArray();
                    mBuffer.SetBytes(buffer, startIndex);
                    return new byte[0];
                }
                else if (command[7] == MelsecMcDataType.X.DataCode)
                {
                    byte[] buffer = SoftBasic.ByteToBoolArray(SoftBasic.BytesArrayRemoveBegin(command, 10)).Select(m => m ? (byte)1 : (byte)0).ToArray();
                    xBuffer.SetBytes(buffer, startIndex);
                    return new byte[0];
                }
                else if (command[7] == MelsecMcDataType.Y.DataCode)
                {
                    byte[] buffer = SoftBasic.ByteToBoolArray(SoftBasic.BytesArrayRemoveBegin(command, 10)).Select(m => m ? (byte)1 : (byte)0).ToArray();
                    yBuffer.SetBytes(buffer, startIndex);
                    return new byte[0];
                }
                else if (command[7] == MelsecMcDataType.D.DataCode)
                {
                    dBuffer.SetBytes(SoftBasic.BytesArrayRemoveBegin(command, 10), startIndex * 2);
                    return new byte[0];
                }
                else if (command[7] == MelsecMcDataType.W.DataCode)
                {
                    wBuffer.SetBytes(SoftBasic.BytesArrayRemoveBegin(command, 10), startIndex * 2);
                    return new byte[0];
                }
                else
                {
                    throw new Exception(StringResources.Language.NotSupportedDataType);
                }
            }
        }

        #endregion

        #region Data Save Load Override

        /// <summary>
        /// 从字节数据加载数据信息
        /// </summary>
        /// <param name="content">字节数据</param>
        protected override void LoadFromBytes(byte[] content)
        {
            if (content.Length < DataPoolLength * 7) throw new Exception("File is not correct");

            mBuffer.SetBytes(content, 0, 0, DataPoolLength);
            xBuffer.SetBytes(content, DataPoolLength, 0, DataPoolLength);
            yBuffer.SetBytes(content, DataPoolLength * 2, 0, DataPoolLength);
            dBuffer.SetBytes(content, DataPoolLength * 3, 0, DataPoolLength);
            wBuffer.SetBytes(content, DataPoolLength * 5, 0, DataPoolLength);
        }

        /// <summary>
        /// 将数据信息存储到字节数组去
        /// </summary>
        /// <returns>所有的内容</returns>
        protected override byte[] SaveToBytes()
        {
            byte[] buffer = new byte[DataPoolLength * 7];
            Array.Copy(mBuffer.GetBytes(), 0, buffer, 0, DataPoolLength);
            Array.Copy(xBuffer.GetBytes(), 0, buffer, DataPoolLength, DataPoolLength);
            Array.Copy(yBuffer.GetBytes(), 0, buffer, DataPoolLength * 2, DataPoolLength);
            Array.Copy(dBuffer.GetBytes(), 0, buffer, DataPoolLength * 3, DataPoolLength);
            Array.Copy(wBuffer.GetBytes(), 0, buffer, DataPoolLength * 5, DataPoolLength);

            return buffer;
        }


        #endregion

        #region IDisposable Support

        /// <summary>
        /// 释放当前的对象
        /// </summary>
        /// <param name="disposing">是否托管对象</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                xBuffer?.Dispose();
                yBuffer?.Dispose();
                mBuffer?.Dispose();
                dBuffer?.Dispose();
                wBuffer?.Dispose();
            }
            base.Dispose(disposing);
        }

        #endregion

        #region Private Member

        private SoftBuffer xBuffer;                    // x寄存器的数据池
        private SoftBuffer yBuffer;                    // y寄存器的数据池
        private SoftBuffer mBuffer;                    // m寄存器的数据池
        private SoftBuffer dBuffer;                    // d寄存器的数据池
        private SoftBuffer wBuffer;                    // w寄存器的数据池

        private const int DataPoolLength = 65536;      // 数据的长度

        #endregion

        #region Object Override

        /// <summary>
        /// 返回表示当前对象的字符串
        /// </summary>
        /// <returns>字符串信息</returns>
        public override string ToString()
        {
            return $"MelsecMcServer[{Port}]";
        }

        #endregion
    }
}