add - 添加Plc类库，包含西门子、欧姆龙、三菱、汇川PLC

SlnMesnac.Common/CommonSetup.cs

@@ -0,0 +1,15 @@
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace SlnMesnac.Common
+{
+    public static class CommonSetup
+    {
+        public static void AddCommonSetup(this IServiceCollection services)
+        {
+            services.AddSingleton<StringChange>();
+        }
+    }
+}

SlnMesnac.Common/SlnMesnac.Common.csproj

@@ -5,4 +5,9 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="8.0.0" />
+    <PackageReference Include="System.Drawing.Common" Version="6.0.0" />
+  </ItemGroup>
+
 </Project>

SlnMesnac.Common/StringChange.cs

@@ -0,0 +1,214 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace SlnMesnac.Common
+{
+    public class StringChange
+    {
+        //private static readonly Lazy<StringChange> lazy = new Lazy<StringChange>(() => new StringChange());
+        //public static StringChange Instance
+        //{
+        //    get
+        //    {
+        //        return lazy.Value;
+        //    }
+        //}
+
+        //private StringChange() { }
+
+        /// <summary>
+        /// 将字符串强制转换成int，转换失败则返回0
+        /// </summary>
+        /// <param name="str"></param>
+        /// <returns></returns>
+        public int ParseToInt(string str)
+        {
+            int returnInt = 0;
+            if (str == null || str.Trim().Length < 1)
+            {
+                return returnInt;
+            }
+            if (int.TryParse(str, out returnInt))
+            {
+                return returnInt;
+            }
+            else
+            {
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// char数组转Array
+        /// </summary>
+        /// <param name="cha"></param>
+        /// <param name="len"></param>
+        /// <returns></returns>
+        public string CharArrayToString(char[] cha, int len)
+        {
+            string str = "";
+            for (int i = 0; i < len; i++)
+            {
+                str += string.Format("{0}", cha[i]);
+            }
+
+            return str;
+        }
+
+        public string bytesToHexStr(byte[] bytes, int iLen)//e.g. { 0x01, 0x01} ---> " 01 01"
+        {
+            string returnStr = "";
+            if (bytes != null)
+            {
+                for (int i = 0; i < iLen; i++)
+                {
+                    returnStr += bytes[i].ToString("X2");
+                }
+            }
+            return returnStr;
+        }
+
+        public byte[] HexStrTorbytes(string strHex)//e.g. " 01 01" ---> { 0x01, 0x01}
+        {
+            strHex = strHex.Replace(" ", "");
+            if ((strHex.Length % 2) != 0)
+                strHex += " ";
+            byte[] returnBytes = new byte[strHex.Length / 2];
+            for (int i = 0; i < returnBytes.Length; i++)
+                returnBytes[i] = Convert.ToByte(strHex.Substring(i * 2, 2), 16);
+            return returnBytes;
+        }
+
+        public string StringToHexString(string s, Encoding encode)
+        {
+            byte[] b = encode.GetBytes(s);          //按照指定编码将string编程字节数组
+            string result = string.Empty;
+            for (int i = 0; i < b.Length; i++)      //逐字节变为16进制字符，以%隔开
+            {
+                result += "%" + Convert.ToString(b[i], 16);
+            }
+            return result;
+        }
+
+        public string HexStringToString(string hs, Encoding encode)
+        {
+            //以%分割字符串，并去掉空字符
+            string[] chars = hs.Split(new char[] { '%' }, StringSplitOptions.RemoveEmptyEntries);
+            byte[] b = new byte[chars.Length];
+            //逐个字符变为16进制字节数据
+            for (int i = 0; i < chars.Length; i++)
+            {
+                b[i] = Convert.ToByte(chars[i], 16);
+            }
+            //按照指定编码将字节数组变为字符串
+            return encode.GetString(b);
+        }
+
+        public byte[] Swap16Bytes(byte[] OldU16)
+        {
+            byte[] ReturnBytes = new byte[2];
+            ReturnBytes[1] = OldU16[0];
+            ReturnBytes[0] = OldU16[1];
+            return ReturnBytes;
+        }
+
+
+        /// <param name="strbase64">64Base码</param>
+        /// <param name="path">保存路径</param>
+        /// <param name="filename">文件名称</param>
+        /// <returns></returns>
+        public bool Base64ToImage(string strbase64, string path, string filename)
+        {
+            bool Flag = false;
+            try
+            {
+                //base64编码的文本 转为 图片
+                //图片名称
+                byte[] arr = Convert.FromBase64String(strbase64);//将指定的字符串（它将二进制数据编码为 Base64 数字）转换为等效的 8 位无符号整数数组。
+                using (MemoryStream ms = new MemoryStream(arr))
+                {
+                    Bitmap bmp = new Bitmap(ms);//加载图像
+                    if (!Directory.Exists(path))//判断保存目录是否存在
+                    {
+                        Directory.CreateDirectory(path);
+                    }
+                    bmp.Save((path + "\\" + filename + ".png"), System.Drawing.Imaging.ImageFormat.Png);//将图片以JPEG格式保存在指定目录(可以选择其他图片格式)
+                    ms.Close();//关闭流并释放
+                    if (File.Exists(path + "\\" + filename + ".png"))//判断是否存在
+                    {
+                        Flag = true;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine("图片保存失败：" + ex.Message);
+            }
+            return Flag;
+        }
+
+        /// <summary>
+        /// 获取时间戳
+        /// </summary>
+        /// <returns></returns>
+        public long GetTimeStamp()
+        {
+            TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
+            return Convert.ToInt64(ts.TotalSeconds);
+        }
+
+        public byte[] ConvertFloatToINt(byte[] floatBytes)
+        {
+            byte[] intBytes = new byte[floatBytes.Length / 2];
+            for (int i = 0; i < intBytes.Length; i++)
+            {
+                intBytes[i] = floatBytes[i * 2];
+            }
+            return intBytes;
+        }
+
+        //CRC异或校验
+        public byte CalculateVerify(byte[] pMessage, int iLength)
+        {
+            UInt16 i;
+            byte iVerify = 0;
+
+            iVerify = pMessage[0];
+            for (i = 1; i < iLength; i++)
+            {
+                iVerify = (byte)(iVerify ^ pMessage[i]);
+            }
+            return iVerify;
+        }
+
+        public int HexStringToNegative(string strNumber)
+        {
+
+            int iNegate = 0;
+            int iNumber = Convert.ToInt32(strNumber, 16);
+            if (iNumber > 127)
+            {
+                int iComplement = iNumber - 1;
+                string strNegate = string.Empty;
+                char[] binchar = Convert.ToString(iComplement, 2).PadLeft(8, '0').ToArray();
+                foreach (char ch in binchar)
+                {
+                    if (Convert.ToInt32(ch) == 48)
+                    {
+                        strNegate += "1";
+                    }
+                    else
+                    {
+                        strNegate += "0";
+                    }
+                }
+                iNegate = -Convert.ToInt32(strNegate, 2);
+            }
+            return iNegate;
+        }
+    }
+}

SlnMesnac.Plc/IPlc.cs

@@ -0,0 +1,118 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace SlnMesnac.Plc
+{
+    public interface IPlc
+    {
+        /// <summary>
+        /// 连接标识
+        /// </summary>
+        bool IsConnected { get; set; }
+
+        /// <summary>
+        /// 建立连接
+        /// </summary>
+        /// <param name="IP"></param>
+        /// <param name="port"></param>
+        /// <returns></returns>
+        bool Connect(string IP, int port);
+
+        /// <summary>
+        /// 断开连接
+        /// </summary>
+        /// <returns></returns>
+        bool DisConnect();
+
+        /// <summary>
+        /// 通过地址和长度读取PLC数据
+        /// </summary>
+        /// <param name="len"></param>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        byte[] readValueByAddress(int len, string address);
+
+        /// <summary>
+        /// 通过PLC地址写入int类型数据
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        bool writeValueByAddress(int value, string address);
+
+        /// <summary>
+        /// 通过PLC地址清零数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="len"></param>
+        /// <returns></returns>
+        bool resetByAddress(string address, int len);
+
+        /// <summary>
+        /// 通过PLC地址读取EA值
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        string readEaByAddress(string address);
+
+        /// <summary>
+        /// 通过PLC地址读取交互信号
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        int readInteractiveSignal(string address);
+
+        /// <summary>
+        /// 通过PLC地址读取int32类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        int readInt32ByAddress(string address);
+
+        /// <summary>
+        /// 通过PLC地址写入int32类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        bool writeInt32ByAddress(string address, int value);
+
+        /// <summary>
+        /// 通过PLC地址读取string类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        string readStringByAddress(string address, ushort length);
+
+        /// <summary>
+        /// 通过PLC地址写入String类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="SFC"></param>
+        /// <returns></returns>
+        bool writeStringByAddress(string address, string value);
+
+        /// <summary>
+        /// 通过PLC地址读取Bool类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        bool readBoolByAddress(string address);
+
+        /// <summary>
+        /// 通过PLC地址写入Bool类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        bool writeBoolByAddress(string address, bool value);
+
+        /// <summary>
+        /// 通过PLC地址写入Double类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        bool writeDoubleByAddress(string address, int value);
+    }
+}

SlnMesnac.Plc/Impl/InovancePlc.cs

@@ -0,0 +1,492 @@
+using HslCommunication.Profinet.Inovance;
+using HslCommunication;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using SlnMesnac.Common;
+using Microsoft.Extensions.Logging;
+
+namespace SlnMesnac.Plc.Impl
+{
+    /// <summary>
+    /// 汇川PLC
+    /// </summary>
+    public class InovancePlc : IPlc
+    {
+        private ILogger<InovancePlc> _logger;
+
+        private StringChange _stringChange;
+
+        private InovanceTcpNet inovanceTcp = null;
+
+        public InovancePlc(ILogger<InovancePlc> logger, StringChange stringChange)
+        {
+            this._logger = logger;
+            _stringChange = stringChange;
+
+            this.inovanceTcp = new InovanceTcpNet();
+            this.inovanceTcp.ConnectTimeOut = 2000;
+        }
+
+        public bool IsConnected { get; set; }
+
+        /// <summary>
+        /// 建立连接
+        /// </summary>
+        /// <param name="IP"></param>
+        /// <param name="port"></param>
+        /// <returns></returns>
+        public bool Connect(string IP, int port)
+        {
+            inovanceTcp?.ConnectClose();
+
+            PrintLogInfo("汇川PLC连接开始");
+            inovanceTcp.IpAddress = IP;
+            inovanceTcp.Port = 502;
+            inovanceTcp.DataFormat = HslCommunication.Core.DataFormat.CDAB;
+            try
+            {
+                OperateResult connect = inovanceTcp.ConnectServer();
+                if (connect.IsSuccess)
+                {
+                    this.IsConnected = true;
+                    PrintLogInfo("汇川PLC建立连接成功！！！");
+                    return true;
+                }
+                else
+                {
+                    this.IsConnected = false;
+                    PrintLogInfo("汇川PLC建立连接失败！！！");
+                    return false;
+                }
+            }
+            catch (Exception ex)
+            {
+                this.IsConnected = false;
+                PrintLogInfo("欧姆龙NJ系列PLC建立连接异常", ex);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 断开连接
+        /// </summary>
+        /// <returns></returns>
+        public bool DisConnect()
+        {
+            return inovanceTcp.ConnectClose().IsSuccess;
+        }
+
+        /// <summary>
+        /// 通过地址和长度读取PLC数据
+        /// </summary>
+        /// <param name="len"></param>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public byte[] readValueByAddress(int len, string address)
+        {
+            //PrintLogInfo("开始通过PLC地址和长度读取PLC数据");
+            try
+            {
+                OperateResult<byte[]> read = inovanceTcp.Read(address, (ushort)(len));
+                if (read.IsSuccess)
+                {
+                    byte[] result = _stringChange.ConvertFloatToINt(read.Content);
+                    PrintLogInfo(String.Format("通过地址和长度读取PLC数据成功：{0}", _stringChange.bytesToHexStr(result, result.Length)));
+                    return result;
+                }
+                else
+                {
+                    PrintLogInfo("通过地址和长度读取PLC数据失败！！！");
+                    this.IsConnected = false;
+                    return new byte[0];
+                }
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过地址和长度读取PLC数据异常", ex);
+                this.IsConnected = false;
+                return new byte[0];
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址写入int类型数据,模切汇川PLC复位逻辑
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool writeValueByAddress(int value, string address)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}写入int类型数据{1}", address, value));
+            OperateResult operateResult = new OperateResult();
+            try
+            {
+                int s = 0;
+                string[] strArry = address.Split('.');
+
+                //先读取整个块的内容
+                var info = inovanceTcp.ReadInt16(strArry[0]);
+                if (info.Content == 0)
+                {
+                    int length = _stringChange.ParseToInt(strArry[1]) + 1;
+                    string[] array = new string[length];
+                    for (int i = 0; i < length; i++)
+                    {
+                        if (i == _stringChange.ParseToInt(strArry[1]))
+                        {
+                            array[i] = value.ToString();
+                        }
+                        else
+                        {
+                            array[i] = "0";
+                        }
+                    }
+                    //反转
+                    Array.Reverse(array);
+                    byte[] buffer = new byte[array.Length];
+                    string result = "";
+                    for (int i = 0; i < array.Length; i++)
+                    {
+                        result += (byte)Convert.ToInt32(array[i], 16);
+                    }
+                    s = Convert.ToInt32(result.Trim(), 2);
+                    operateResult = inovanceTcp.Write(strArry[0], (ushort)s);
+                }
+                else
+                {
+                    var inf2 = Convert.ToString(info.Content, 2);
+                    string[] infoArray = new string[inf2.Length];
+                    for (int i = 0; i < inf2.Length; i++)
+                    {
+                        infoArray[i] = inf2.Substring(i, 1);
+                    }
+                    Array.Reverse(infoArray);
+                    infoArray[_stringChange.ParseToInt(strArry[1])] = value.ToString();
+                    string result = "";
+                    foreach (var item in infoArray)
+                    {
+                        result = result + item;
+                    }
+                    s = Convert.ToInt32(result.Trim(), 10);
+                    operateResult = inovanceTcp.Write(strArry[0], s);
+                }
+                if (operateResult.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("开始通过PLC地址{0}写入int类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("开始通过PLC地址{0}写入int类型数据{1}失败！！！", address, value));
+                this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址写入int类型数据", ex);
+                this.IsConnected = false;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址清零数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="len"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool resetByAddress(string address, int len)
+        {
+            // PrintLogInfo(String.Format("开发通过PLC地址{0}清零数据", address));
+            try
+            {
+                byte[] write = new byte[len * 2];
+                for (int i = 0; i < len * 2; i++)
+                {
+                    write[i] = 0;
+                }
+                OperateResult operateResult = inovanceTcp.Write(address, write);
+
+                if (operateResult.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}清零数据成功", address));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}清零数据失败！！！", address));
+                this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}清零数据异常", address), ex);
+                this.IsConnected = false;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取EA值
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public string readEaByAddress(string address)
+        {
+            //PrintLogInfo(String.Format("通过PLC地址{0}读取EA值", address));
+            try
+            {
+                OperateResult<Byte[]> read = inovanceTcp.Read(address, (ushort)(8));
+
+                if (read.IsSuccess && read.Content != null)
+                {
+                    string result = Convert.ToString(read.Content);
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取EA值成功：{1}", address, result));
+                    return result;
+                }
+                else
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取EA值失败！！！", address));
+                    this.IsConnected = false;
+                    return "";
+                }
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取EA值异常", ex);
+                this.IsConnected = false;
+                return "";
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取交互信号
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        public int readInteractiveSignal(string address)
+        {
+            // PrintLogInfo(String.Format("开始通过PLC地址{0}读取交互信号", address));
+            try
+            {
+                OperateResult<short> read = inovanceTcp.ReadInt16(address);
+                if (read.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取交互信号成功：{1}", address, read.Content));
+                    return read.Content;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}读取交互信号失败！！！", address));
+                this.IsConnected = false;
+                return 0;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取交互信号异常", ex);
+                this.IsConnected = false;
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取int32类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        public int readInt32ByAddress(string address)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}读取int32类型数据", address));
+            try
+            {
+                OperateResult<short> read = inovanceTcp.ReadInt16(address);
+                if (read.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取int32类型数据成功：{1}", address, read.Content));
+                    return read.Content;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}读取int32类型数据失败！！！", address));
+                this.IsConnected = false;
+                return 0;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取int32类型数据异常", ex);
+                this.IsConnected = false;
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址写入int32类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool writeInt32ByAddress(string address, int value)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}写入int32类型数据{1}", address, value));
+            try
+            {
+                OperateResult write = inovanceTcp.Write(address, short.Parse(Convert.ToString(value)));
+                if (write.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}写入int32类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}写入int32类型数据{1}失败！！！", address, value));
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}写入int32类型数据异常", address), ex);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址写入String类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool writeStringByAddress(string address, string value)
+        {
+            //PrintLogInfo(String.Format("通过PLC地址{0}写入String类型数据{1}", address, value));
+            try
+            {
+                OperateResult operateResult = inovanceTcp.Write(address, value);
+                if (operateResult.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}写入String类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}写入String类型数据{1}失败！！！", address, value));
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}写入String类型数据异常", address), ex);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取string类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public string readStringByAddress(string address, ushort length)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}读取string类型数据", address));
+            try
+            {
+                OperateResult<String> read = inovanceTcp.ReadString(address, length);
+                if (read.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取string类型数据成功：{1}", address, read.Content));
+                    return read.Content;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}读取string类型数据失败！！！", address));
+                return "";
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取int32类型数据异常", ex);
+                return "";
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取Bool类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool readBoolByAddress(string address)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}读取bool类型数据", address));
+            try
+            {
+                OperateResult<bool> read = inovanceTcp.ReadBool(address);
+                if (read.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取bool类型数据成功{1}", address, read.Content));
+                    return read.Content;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}读取bool类型数据失败！！！", address));
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取bool类型数据异常", ex);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址写入Bool类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool writeBoolByAddress(string address, bool value)
+        {
+            // PrintLogInfo(String.Format("开始通过PLC地址{0}写入bool类型数据{1}", address, value));
+            try
+            {
+
+                OperateResult write = inovanceTcp.Write(address, value);
+
+                if (write.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}写入bool类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}写入bool类型数据{1}失败！！！", address, value));
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}写入bool类型数据异常", address), ex);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 写入Double类型
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public bool writeDoubleByAddress(string address, int value)
+        {
+            try
+            {
+                OperateResult write = inovanceTcp.Write(address, Convert.ToDouble(value));
+
+                if (write.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}写入Double类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}写入Double类型数据{1}失败！！！", address, value));
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}写入Double类型数据异常", address), ex);
+                return false;
+            }
+        }
+
+        private void PrintLogInfo(string message, Exception ex = null)
+        {
+
+        }
+
+    }
+}

SlnMesnac.Plc/Impl/MelsecBinaryPlc.cs

@@ -0,0 +1,443 @@
+using HslCommunication.Profinet.Melsec;
+using HslCommunication;
+using SlnMesnac.Common;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Microsoft.Extensions.Logging;
+
+namespace SlnMesnac.Plc.Impl
+{
+    /// <summary>
+    /// 三菱Q系列Plc-Binary
+    /// </summary>
+    public class MelsecBinaryPlc : IPlc
+    {
+        private ILogger<MelsecBinaryPlc> _logger;
+
+        private StringChange _stringChange;
+
+        private MelsecMcNet melsec_net = null;
+
+        public MelsecBinaryPlc(ILogger<MelsecBinaryPlc> logger, StringChange stringChange)
+        {
+            _logger = logger;
+            _stringChange = stringChange;
+
+            this.melsec_net = new MelsecMcNet();
+            this.melsec_net.ConnectTimeOut = 2000;
+        }
+
+        public bool IsConnected { get; set; }
+
+        /// <summary>
+        /// 建立连接
+        /// </summary>
+        /// <param name="IP"></param>
+        /// <param name="port"></param>
+        /// <returns></returns>
+        public bool Connect(string IP, int port)
+        {
+            PrintLogInfo("三菱Q系列PLC连接开始");
+            melsec_net.IpAddress = IP;
+            melsec_net.Port = port;
+            try
+            {
+                OperateResult connect = melsec_net.ConnectServer();
+                if (connect.IsSuccess)
+                {
+                    this.IsConnected = true;
+                    PrintLogInfo("三菱Q系列PLC建立连接成功！！！");
+                    return true;
+                }
+                else
+                {
+                    this.IsConnected = false;
+                    PrintLogInfo("三菱Q系列PLC建立连接失败！！！");
+                    return false;
+                }
+            }
+            catch (Exception ex)
+            {
+                this.IsConnected = false;
+                PrintLogInfo("三菱Q系列PLC建立连接异常", ex);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 断开连接
+        /// </summary>
+        /// <returns></returns>
+        public bool DisConnect()
+        {
+            return melsec_net.ConnectClose().IsSuccess;
+        }
+
+        /// <summary>
+        /// 通过地址和长度读取PLC数据
+        /// </summary>
+        /// <param name="len"></param>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public byte[] readValueByAddress(int len, string address)
+        {
+            //PrintLogInfo("开始通过PLC地址和长度读取PLC数据");
+            try
+            {
+                OperateResult<byte[]> read = melsec_net.Read(address, (ushort)(len));
+                if (read.IsSuccess)
+                {
+                    byte[] result = _stringChange.ConvertFloatToINt(read.Content);
+                    PrintLogInfo(String.Format("通过地址和长度读取PLC数据成功：{0}", _stringChange.bytesToHexStr(result, result.Length)));
+                    return result;
+                }
+                else
+                {
+                    PrintLogInfo("通过地址和长度读取PLC数据失败！！！");
+                    this.IsConnected = false;
+                    return new byte[0];
+                }
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过地址和长度读取PLC数据异常", ex);
+                this.IsConnected = false;
+                return new byte[0];
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址写入int类型数据
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool writeValueByAddress(int value, string address)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}写入int类型数据{1}",address,value));
+            try
+            {
+                OperateResult operateResult = melsec_net.Write(address, Convert.ToInt32(value));
+                if (operateResult.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("开始通过PLC地址{0}写入int类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("开始通过PLC地址{0}写入int类型数据{1}失败！！！", address, value));
+                this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址写入int类型数据", ex);
+                this.IsConnected = false;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址清零数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="len"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool resetByAddress(string address, int len)
+        {
+            //PrintLogInfo(String.Format("开发通过PLC地址{0}清零数据", address));
+            try
+            {
+                byte[] write = new byte[len * 2];
+                for (int i = 0; i < len * 2; i++)
+                {
+                    write[i] = 0;
+                }
+                OperateResult operateResult = melsec_net.Write(address, write);
+
+                if (operateResult.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}清零数据成功", address));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}清零数据失败！！！", address));
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}清零数据异常", address), ex);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取EA值
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public string readEaByAddress(string address)
+        {
+            //PrintLogInfo(String.Format("通过PLC地址{0}读取EA值", address));
+            try
+            {
+                OperateResult<Byte[]> read = melsec_net.Read(address, (ushort)(8));
+
+                if (read.IsSuccess && read.Content != null)
+                {
+                    string result = Convert.ToString(read.Content);
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取EA值成功：{1}", address, result));
+                    return result;
+                }
+                else
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取EA值失败！！！", address));
+                    this.IsConnected = false;
+                    return "";
+                }
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取EA值异常", ex);
+                this.IsConnected = false;
+                return "";
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取交互信号
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        public int readInteractiveSignal(string address)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}读取交互信号", address));
+            try
+            {
+                OperateResult<short> read = melsec_net.ReadInt16(address);
+                if (read.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取交互信号成功：{1}", address, read.Content));
+                    return read.Content;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}读取交互信号失败！！！", address));
+                this.IsConnected = false;
+                return 0;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取交互信号异常", ex);
+                this.IsConnected = false;
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取int32类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        public int readInt32ByAddress(string address)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}读取int32类型数据",address));
+            try
+            {
+                OperateResult<short> read = melsec_net.ReadInt16(address);
+                if (read.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取int32类型数据成功：{1}", address, read.Content));
+                    return read.Content;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}读取int32类型数据失败！！！", address));
+                this.IsConnected = false;
+                return 0;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取int32类型数据异常", ex);
+                this.IsConnected = false;
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址写入int32类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool writeInt32ByAddress(string address, int value)
+        {
+            PrintLogInfo(String.Format("开始通过PLC地址{0}写入int32类型数据{1}", address, value));
+            try
+            {
+                OperateResult write = melsec_net.Write(address, short.Parse(Convert.ToString(value)));
+                if (write.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}写入int32类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}写入int32类型数据{1}失败！！！", address, value));
+                this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}写入int32类型数据异常", address), ex);
+                this.IsConnected = false;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址写入String类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool writeStringByAddress(string address, string value)
+        {
+            //PrintLogInfo(String.Format("通过PLC地址{0}写入String类型数据{1}",address,value));
+            try
+            {
+                OperateResult operateResult = melsec_net.Write(address, value);
+                if (operateResult.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}写入String类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}写入String类型数据{1}失败！！！", address, value));
+                //this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}写入String类型数据异常", address), ex);
+                //this.IsConnected = false;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取string类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public string readStringByAddress(string address, ushort length)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}读取string类型数据", address));
+            try
+            {
+                OperateResult<String> read = melsec_net.ReadString(address, length);
+                if (read.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取string类型数据成功：{1}", address, read.Content));
+                    return read.Content;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}读取string类型数据失败！！！", address));
+                this.IsConnected = false;
+                return "";
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取int32类型数据异常", ex);
+                return "";
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取Bool类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool readBoolByAddress(string address)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}读取bool类型数据", address));
+            try
+            {
+                OperateResult<bool> read = melsec_net.ReadBool(address);
+                if (read.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取bool类型数据成功：{1}", address, read.Content));
+                    return read.Content;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}读取bool类型数据失败！！！", address));
+                this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取int32类型数据异常", ex);
+                this.IsConnected = false;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址写入Bool类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public bool writeBoolByAddress(string address, bool value)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}写入bool类型数据{1}", address, value));
+            try
+            {
+                OperateResult write = melsec_net.Write(address, short.Parse(_stringChange.ParseToInt(value ? "1" : "0").ToString()));
+                if (write.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}写入bool类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}写入bool类型数据{1}失败！！！", address, value));
+                this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}写入bool类型数据异常", address), ex);
+                this.IsConnected = false;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 写入Double类型
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public bool writeDoubleByAddress(string address, int value)
+        {
+            try
+            {
+                OperateResult write = melsec_net.Write(address, Convert.ToDouble(value));
+
+                if (write.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}写入Double类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}写入Double类型数据{1}失败！！！", address, value));
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}写入Double类型数据异常", address), ex);
+                return false;
+            }
+        }
+
+        private void PrintLogInfo(string message, Exception ex = null)
+        {
+
+        }
+    }
+}

SlnMesnac.Plc/Impl/OmronNJPlc.cs

@@ -0,0 +1,448 @@
+using HslCommunication.Profinet.Omron;
+using HslCommunication;
+using SlnMesnac.Common;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Microsoft.Extensions.Logging;
+
+namespace SlnMesnac.Plc.Impl
+{
+    /// <summary>
+    /// 欧姆龙NJ系列PLC
+    /// </summary>
+    public class OmronNJPlc : IPlc
+    {
+
+        private ILogger<OmronNJPlc> _logger;
+
+        private StringChange _stringChange;
+
+        private OmronFinsNet omronFinsNet = null;
+
+        public OmronNJPlc(ILogger<OmronNJPlc> logger,StringChange stringChange)
+        {
+            _logger = logger;
+            _stringChange = stringChange;
+
+            this.omronFinsNet = new OmronFinsNet();
+            this.omronFinsNet.ConnectTimeOut = 2000;
+        }
+
+        public bool IsConnected { get; set; }
+
+        /// <summary>
+        /// 建立连接
+        /// </summary>
+        /// <param name="IP"></param>
+        /// <param name="port"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool Connect(string IP, int port)
+        {
+            PrintLogInfo("欧姆龙NJ系列PLC连接开始");
+            omronFinsNet.IpAddress = IP;
+            omronFinsNet.Port = 9600;
+            omronFinsNet.SA1 = (byte)192;
+            omronFinsNet.DA1 = (byte)239;
+            omronFinsNet.DA2 = (byte)0;
+            try
+            {
+                OperateResult connect = omronFinsNet.ConnectServer();
+                if (connect.IsSuccess)
+                {
+                    this.IsConnected = true;
+                    PrintLogInfo("欧姆龙NJ系列PLC建立连接成功！！！");
+                    return true;
+                }
+                else
+                {
+                    this.IsConnected = false;
+                    PrintLogInfo("欧姆龙NJ系列PLC建立连接失败！！！");
+                    return false;
+                }
+            }
+            catch (Exception ex)
+            {
+                this.IsConnected = false;
+                PrintLogInfo("欧姆龙NJ系列PLC建立连接异常", ex);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 断开连接
+        /// </summary>
+        /// <returns></returns>
+        public bool DisConnect()
+        {
+            return omronFinsNet.ConnectClose().IsSuccess;
+        }
+
+        /// <summary>
+        /// 通过地址和长度读取PLC数据
+        /// </summary>
+        /// <param name="len"></param>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public byte[] readValueByAddress(int len, string address)
+        {
+            //PrintLogInfo("开始通过PLC地址和长度读取PLC数据");
+            try
+            {
+                OperateResult<byte[]> read = omronFinsNet.Read(address, (ushort)(len));
+                if (read.IsSuccess)
+                {
+                    byte[] result = _stringChange.ConvertFloatToINt(read.Content);
+                    PrintLogInfo(String.Format("通过地址和长度读取PLC数据成功：{0}", _stringChange.bytesToHexStr(result, result.Length)));
+                    return result;
+                }
+                else
+                {
+                    PrintLogInfo("通过地址和长度读取PLC数据失败！！！");
+                    this.IsConnected = false;
+                    return new byte[0];
+                }
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过地址和长度读取PLC数据异常", ex);
+                this.IsConnected = false;
+                return new byte[0];
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址写入int类型数据
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool writeValueByAddress(int value, string address)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}写入int类型数据{1}",address,value));
+            try
+            {
+                OperateResult operateResult = omronFinsNet.Write(address, Convert.ToInt32(value));
+                if (operateResult.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("开始通过PLC地址{0}写入int类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("开始通过PLC地址{0}写入int类型数据{1}失败！！！", address, value));
+                this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址写入int类型数据", ex);
+                this.IsConnected = false;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址清零数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="len"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool resetByAddress(string address, int len)
+        {
+            //PrintLogInfo(String.Format("开发通过PLC地址{0}清零数据", address));
+            try
+            {
+                byte[] write = new byte[len * 2];
+                for (int i = 0; i < len * 2; i++)
+                {
+                    write[i] = 0;
+                }
+                OperateResult operateResult = omronFinsNet.Write(address, write);
+
+                if (operateResult.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}清零数据成功", address));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}清零数据失败！！！", address));
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}清零数据异常", address), ex);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取EA值
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public string readEaByAddress(string address)
+        {
+            //PrintLogInfo(String.Format("通过PLC地址{0}读取EA值", address));
+            try
+            {
+                OperateResult<Byte[]> read = omronFinsNet.Read(address, (ushort)(8));
+
+                if (read.IsSuccess && read.Content != null)
+                {
+                    string result = Convert.ToString(read.Content);
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取EA值成功：{1}", address, result));
+                    return result;
+                }
+                else
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取EA值失败！！！", address));
+                    this.IsConnected = false;
+                    return "";
+                }
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取EA值异常", ex);
+                this.IsConnected = false;
+                return "";
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取交互信号
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        public int readInteractiveSignal(string address)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}读取交互信号", address));
+            try
+            {
+                OperateResult<short> read = omronFinsNet.ReadInt16(address);
+                if (read.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取交互信号成功：{1}", address, read.Content));
+                    return read.Content;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}读取交互信号失败！！！", address));
+                this.IsConnected = false;
+                return 0;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取交互信号异常", ex);
+                this.IsConnected = false;
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取int32类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        public int readInt32ByAddress(string address)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}读取int32类型数据",address));
+            try
+            {
+                OperateResult<short> read = omronFinsNet.ReadInt16(address);
+                if (read.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取int32类型数据成功：{1}", address, read.Content));
+                    return read.Content;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}读取int32类型数据失败！！！", address));
+                this.IsConnected = false;
+                return 0;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取int32类型数据异常", ex);
+                this.IsConnected = false;
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址写入int32类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool writeInt32ByAddress(string address, int value)
+        {
+            PrintLogInfo(String.Format("开始通过PLC地址{0}写入int32类型数据{1}", address, value));
+            try
+            {
+                OperateResult write = omronFinsNet.Write(address, short.Parse(Convert.ToString(value)));
+                if (write.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}写入int32类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}写入int32类型数据{1}失败！！！", address, value));
+                this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}写入int32类型数据异常", address), ex);
+                this.IsConnected = false;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址写入String类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool writeStringByAddress(string address, string value)
+        {
+            //PrintLogInfo(String.Format("通过PLC地址{0}写入String类型数据{1}",address,value));
+            try
+            {
+                OperateResult operateResult = omronFinsNet.Write(address, value);
+                if (operateResult.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}写入String类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}写入String类型数据{1}失败！！！", address, value));
+                //this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}写入String类型数据异常", address), ex);
+                //this.IsConnected = false;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取string类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public string readStringByAddress(string address, ushort length)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}读取string类型数据", address));
+            try
+            {
+                OperateResult<String> read = omronFinsNet.ReadString(address, length);
+                if (read.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取string类型数据成功：{1}", address, read.Content));
+                    return read.Content;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}读取string类型数据失败！！！", address));
+                this.IsConnected = false;
+                return "";
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取int32类型数据异常", ex);
+                return "";
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取Bool类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool readBoolByAddress(string address)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}读取bool类型数据", address));
+            try
+            {
+                OperateResult<bool> read = omronFinsNet.ReadBool(address);
+                if (read.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取bool类型数据成功：{1}", address, read.Content));
+                    return read.Content;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}读取bool类型数据失败！！！", address));
+                this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取int32类型数据异常", ex);
+                this.IsConnected = false;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址写入Bool类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public bool writeBoolByAddress(string address, bool value)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}写入bool类型数据{1}", address, value));
+            try
+            {
+                OperateResult write = omronFinsNet.Write(address, short.Parse(_stringChange.ParseToInt(value ? "1" : "0").ToString()));
+                if (write.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}写入bool类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}写入bool类型数据{1}失败！！！", address, value));
+                this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}写入bool类型数据异常", address), ex);
+                this.IsConnected = false;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 写入Double类型
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public bool writeDoubleByAddress(string address, int value)
+        {
+            try
+            {
+                OperateResult write = omronFinsNet.Write(address, Convert.ToDouble(value));
+
+                if (write.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}写入Double类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}写入Double类型数据{1}失败！！！", address, value));
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}写入Double类型数据异常", address), ex);
+                return false;
+            }
+        }
+
+        private void PrintLogInfo(string message, Exception ex = null)
+        {
+
+        }
+    }
+}

SlnMesnac.Plc/Impl/SiemensPlc.cs

@@ -0,0 +1,415 @@
+using HslCommunication.Profinet.Siemens;
+using HslCommunication;
+using SlnMesnac.Common;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Microsoft.Extensions.Logging;
+
+namespace SlnMesnac.Plc.Impl
+{
+    public class SiemensPlc : IPlc
+    {
+        private ILogger<SiemensPlc> _logger;
+
+        private StringChange _stringChange;
+
+        private const SiemensPLCS type = SiemensPLCS.S200Smart;
+
+        private SiemensS7Net s7 = new SiemensS7Net(type);
+
+        public SiemensPlc(ILogger<SiemensPlc> logger, StringChange stringChange)
+        {
+            this._logger = logger;
+            _stringChange = stringChange;
+
+        }
+
+        public bool IsConnected { get; set; }
+
+        /// <summary>
+        /// 建立连接
+        /// </summary>
+        /// <param name="IP"></param>
+        /// <param name="port"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool Connect(string IP, int port)
+        {
+            PrintLogInfo("西门子S7系列PLC连接开始");
+            s7.IpAddress = IP;
+            s7.Port = 102;
+            try
+            {
+                OperateResult connect = s7.ConnectServer();
+                if (connect.IsSuccess)
+                {
+                    this.IsConnected = true;
+                    PrintLogInfo("西门子S7系列PLC建立连接成功！！！");
+                    return true;
+                }
+                else
+                {
+                    this.IsConnected = false;
+                    PrintLogInfo("西门子S7系列PLC建立连接失败！！！");
+                    return false;
+                }
+            }
+            catch (Exception ex)
+            {
+                this.IsConnected = false;
+                PrintLogInfo("西门子S7系列PLC建立连接异常", ex);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过地址和长度读取PLC数据
+        /// </summary>
+        /// <param name="len"></param>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public byte[] readValueByAddress(int len, string address)
+        {
+            //PrintLogInfo("开始通过PLC地址和长度读取PLC数据");
+            try
+            {
+                OperateResult<byte[]> read = s7.Read(address, (ushort)(len));
+                if (read.IsSuccess)
+                {
+                    byte[] result = _stringChange.ConvertFloatToINt(read.Content);
+                    PrintLogInfo(String.Format("通过地址和长度读取PLC数据成功：{0}", _stringChange.bytesToHexStr(result, result.Length)));
+                    return result;
+                }
+                else
+                {
+                    PrintLogInfo("通过地址和长度读取PLC数据失败！！！");
+                    this.IsConnected = false;
+                    return new byte[0];
+                }
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过地址和长度读取PLC数据异常", ex);
+                this.IsConnected = false;
+                return new byte[0];
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址写入int类型数据
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool writeValueByAddress(int value, string address)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}写入int类型数据{1}",address,value));
+            try
+            {
+                OperateResult operateResult = s7.Write(address, Convert.ToInt32(value));
+                if (operateResult.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("开始通过PLC地址{0}写入int类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("开始通过PLC地址{0}写入int类型数据{1}失败！！！", address, value));
+                this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址写入int类型数据", ex);
+                this.IsConnected = false;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址清零数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="len"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool resetByAddress(string address, int len)
+        {
+            //PrintLogInfo(String.Format("开发通过PLC地址{0}清零数据", address));
+            try
+            {
+                byte[] write = new byte[len * 2];
+                for (int i = 0; i < len * 2; i++)
+                {
+                    write[i] = 0;
+                }
+                OperateResult operateResult = s7.Write(address, write);
+
+                if (operateResult.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}清零数据成功", address));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}清零数据失败！！！", address));
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}清零数据异常", address), ex);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取EA值
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public string readEaByAddress(string address)
+        {
+            //PrintLogInfo(String.Format("通过PLC地址{0}读取EA值", address));
+            try
+            {
+                OperateResult<Byte[]> read = s7.Read(address, (ushort)(8));
+
+                if (read.IsSuccess && read.Content != null)
+                {
+                    string result = Convert.ToString(read.Content);
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取EA值成功：{1}", address, result));
+                    return result;
+                }
+                else
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取EA值失败！！！", address));
+                    this.IsConnected = false;
+                    return "";
+                }
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取EA值异常", ex);
+                this.IsConnected = false;
+                return "";
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取交互信号
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        public int readInteractiveSignal(string address)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}读取交互信号", address));
+            try
+            {
+                OperateResult<short> read = s7.ReadInt16(address);
+                if (read.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取交互信号成功：{1}", address, read.Content));
+                    return read.Content;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}读取交互信号失败！！！", address));
+                this.IsConnected = false;
+                return 0;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取交互信号异常", ex);
+                this.IsConnected = false;
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取int32类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        public int readInt32ByAddress(string address)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}读取int32类型数据",address));
+            try
+            {
+                OperateResult<short> read = s7.ReadInt16(address);
+                if (read.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取int32类型数据成功：{1}", address, read.Content));
+                    return read.Content;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}读取int32类型数据失败！！！", address));
+                this.IsConnected = false;
+                return 0;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取int32类型数据异常", ex);
+                this.IsConnected = false;
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址写入int32类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool writeInt32ByAddress(string address, int value)
+        {
+            PrintLogInfo(String.Format("开始通过PLC地址{0}写入int32类型数据{1}", address, value));
+            try
+            {
+                OperateResult write = s7.Write(address, short.Parse(Convert.ToString(value)));
+                if (write.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}写入int32类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}写入int32类型数据{1}失败！！！", address, value));
+                this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}写入int32类型数据异常", address), ex);
+                this.IsConnected = false;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址写入String类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool writeStringByAddress(string address, string value)
+        {
+            //PrintLogInfo(String.Format("通过PLC地址{0}写入String类型数据{1}",address,value));
+            try
+            {
+                OperateResult operateResult = s7.Write(address, value);
+                if (operateResult.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}写入String类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}写入String类型数据{1}失败！！！", address, value));
+                //this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}写入String类型数据异常", address), ex);
+                //this.IsConnected = false;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取string类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public string readStringByAddress(string address, ushort length)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}读取string类型数据", address));
+            try
+            {
+                OperateResult<String> read = s7.ReadString(address, length);
+                if (read.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取string类型数据成功：{1}", address, read.Content));
+                    return read.Content;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}读取string类型数据失败！！！", address));
+                this.IsConnected = false;
+                return "";
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取int32类型数据异常", ex);
+                return "";
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址读取Bool类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool readBoolByAddress(string address)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}读取bool类型数据", address));
+            try
+            {
+                OperateResult<bool> read = s7.ReadBool(address);
+                if (read.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}读取bool类型数据成功：{1}", address, read.Content));
+                    return read.Content;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}读取bool类型数据失败！！！", address));
+                this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo("通过PLC地址读取int32类型数据异常", ex);
+                this.IsConnected = false;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 通过PLC地址写入Bool类型数据
+        /// </summary>
+        /// <param name="address"></param>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public bool writeBoolByAddress(string address, bool value)
+        {
+            //PrintLogInfo(String.Format("开始通过PLC地址{0}写入bool类型数据{1}", address, value));
+            try
+            {
+                OperateResult write = s7.Write(address, short.Parse(_stringChange.ParseToInt(value ? "1" : "0").ToString()));
+                if (write.IsSuccess)
+                {
+                    PrintLogInfo(String.Format("通过PLC地址{0}写入bool类型数据{1}成功", address, value));
+                    return true;
+                }
+                PrintLogInfo(String.Format("通过PLC地址{0}写入bool类型数据{1}失败！！！", address, value));
+                this.IsConnected = false;
+                return false;
+            }
+            catch (Exception ex)
+            {
+                PrintLogInfo(String.Format("通过PLC地址{0}写入bool类型数据异常", address), ex);
+                this.IsConnected = false;
+                return false;
+            }
+        }
+
+        public bool DisConnect()
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool writeDoubleByAddress(string address, int value)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PrintLogInfo(string message, Exception ex = null)
+        {
+
+        }
+    }
+}

SlnMesnac.Plc/PlcPool.cs

@@ -0,0 +1,127 @@
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json.Linq;
+using SlnMesnac.Plc.Impl;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace SlnMesnac.Plc
+{
+    /// <summary>
+    /// PLC连接池
+    /// </summary>
+    public class PlcPool
+    {
+
+        private ILogger<PlcPool> _logger;
+
+        private Dictionary<string, IPlc> keyValuePairs = new Dictionary<string, IPlc>();
+
+        private readonly InovancePlc _inovancePlc;
+        private readonly MelsecBinaryPlc _melsecBinaryPlc;
+        private readonly OmronNJPlc _omronNJPlc;
+        private readonly SiemensPlc _siemensPlc;
+
+        public PlcPool(ILogger<PlcPool> logger, InovancePlc inovancePlc,MelsecBinaryPlc melsecBinaryPlc,OmronNJPlc omronNJPlc,SiemensPlc siemensPlc)
+        {
+            _logger = logger;
+            _inovancePlc = inovancePlc;
+            _melsecBinaryPlc = melsecBinaryPlc;
+            _omronNJPlc = omronNJPlc;
+            _siemensPlc = siemensPlc;
+
+            if (!HslCommunication.Authorization.SetAuthorizationCode("ed1415f8-e06a-43ad-95f7-c04f7ae93b41"))
+            {
+                _logger.LogInformation("HslCommunication激活失败，可用时长24小时");
+            }
+            _logger.LogInformation("HslCommunication 11.0.6.0激活成功");
+        }
+
+        /// <summary>
+        /// 初始化Plc
+        /// </summary>
+        /// <param name="plcType"></param>
+        /// <param name="ip"></param>
+        /// <param name="port"></param>
+        /// <param name="key"></param>
+        public void InitPlc(string plcType, string ip, int port, string key)
+        {
+            IPlc _plc = null;
+            switch (plcType)
+            {
+                case "InovancePlc":
+                    _plc = _inovancePlc;
+                    break;
+                case "MelsecBinaryPlc":
+                    _plc = _melsecBinaryPlc;
+                    break;
+                case "OmronNJPlc":
+                    _plc = _omronNJPlc;
+                    break;
+                case "SiemensPlc":
+                    _plc = _siemensPlc;
+                    break;
+                default:
+                    break;
+            }
+            var connectResult = _plc.Connect(ip, port);
+            if (connectResult)
+            {
+                keyValuePairs.Add(key, _plc);
+                if (!keyValuePairs.ContainsKey(key))
+                {
+                    keyValuePairs.Add(key, _plc);
+                }
+                else
+                {
+                    keyValuePairs[key] = _plc;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 获取PLC
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public IPlc GetPlcByKey(string key)
+        {
+            return keyValuePairs[key];
+        }
+
+        /// <summary>
+        /// 获取所有PLC信息
+        /// </summary>
+        /// <returns></returns>
+        public Dictionary<string, IPlc> GetAll()
+        {
+            return keyValuePairs;
+        }
+
+        /// <summary>
+        /// 关闭所有连接
+        /// </summary>
+        /// <returns></returns>
+        public bool disConnectAll()
+        {
+            bool result = false;
+            try
+            {
+                foreach (var kv in keyValuePairs)
+                {
+                    if (kv.Value != null)
+                    {
+                        kv.Value.DisConnect();
+                    }
+                }
+                result = true;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError("关闭PLC连接异常", ex);
+            }
+
+            return result;
+        }
+    }
+}

SlnMesnac.Plc/PlcSetup.cs

@@ -0,0 +1,21 @@
+using Microsoft.Extensions.DependencyInjection;
+using SlnMesnac.Common;
+using SlnMesnac.Plc.Impl;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace SlnMesnac.Plc
+{
+    public static class PlcSetup
+    {
+        public static void AddPlcSetup(this IServiceCollection services)
+        {
+            services.AddSingleton<InovancePlc>();
+            services.AddSingleton<MelsecBinaryPlc>();
+            services.AddSingleton<OmronNJPlc>();
+            services.AddSingleton<SiemensPlc>();
+            services.AddSingleton<PlcPool>();
+        }
+    }
+}

SlnMesnac.Plc/SlnMesnac.Plc.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.1</TargetFramework>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="HslCommunication" Version="11.0.6" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\SlnMesnac.Common\SlnMesnac.Common.csproj" />
+  </ItemGroup>
+
+</Project>

SlnMesnac.sln

@@ -17,6 +17,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SlnMesnac.Quartz", "SlnMesn
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SlnMesnac.Serilog", "SlnMesnac.Serilog\SlnMesnac.Serilog.csproj", "{DEE2F305-733C-47C8-891C-502121ABAD00}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SlnMesnac.Plc", "SlnMesnac.Plc\SlnMesnac.Plc.csproj", "{D17E9024-9D25-4CE4-8E98-8A6C859CE436}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -51,6 +53,10 @@ Global
 		{DEE2F305-733C-47C8-891C-502121ABAD00}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{DEE2F305-733C-47C8-891C-502121ABAD00}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{DEE2F305-733C-47C8-891C-502121ABAD00}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D17E9024-9D25-4CE4-8E98-8A6C859CE436}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D17E9024-9D25-4CE4-8E98-8A6C859CE436}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D17E9024-9D25-4CE4-8E98-8A6C859CE436}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D17E9024-9D25-4CE4-8E98-8A6C859CE436}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

SlnMesnac/Controllers/BaseUserController.cs

@@ -1,6 +1,7 @@
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using SlnMesnac.Model.domain;
+using SlnMesnac.Plc;
 using SlnMesnac.Repository.service;
 
 namespace SlnMesnac.Controllers
@@ -16,15 +17,18 @@ namespace SlnMesnac.Controllers
 
         private readonly IBaseUserService _service;
 
+        private readonly PlcPool _plcPool;
+
         /// <summary>
         /// 
         /// </summary>
         /// <param name="logger"></param>
         /// <param name="service"></param>
-        public BaseUserController(ILogger<BaseUserController> logger, IBaseUserService service)
+        public BaseUserController(ILogger<BaseUserController> logger, IBaseUserService service, PlcPool plcPool)
         {
             _logger = logger;
             _service = service;
+            _plcPool = plcPool;
         }
 
         /// <summary>
@@ -34,6 +38,7 @@ namespace SlnMesnac.Controllers
         [HttpGet]
         public IEnumerable<BaseUser> Get()
         {
+            _plcPool.InitPlc("SiemensPlc", "127.0.0.1", 102, "SiemensPlc");
             IEnumerable<BaseUser> users = null;
             try
             {

SlnMesnac/SlnMesnac.csproj

@@ -14,6 +14,7 @@
   <ItemGroup>
     <ProjectReference Include="..\SlnMesnac.Config\SlnMesnac.Config.csproj" />
     <ProjectReference Include="..\SlnMesnac.Model\SlnMesnac.Model.csproj" />
+    <ProjectReference Include="..\SlnMesnac.Plc\SlnMesnac.Plc.csproj" />
     <ProjectReference Include="..\SlnMesnac.Quartz\SlnMesnac.Quartz.csproj" />
     <ProjectReference Include="..\SlnMesnac.Repository\SlnMesnac.Repository.csproj" />
     <ProjectReference Include="..\SlnMesnac.Serilog\SlnMesnac.Serilog.csproj" />

SlnMesnac/Startup.cs

@@ -1,7 +1,10 @@
 using Microsoft.OpenApi.Models;
 using Serilog;
 using Serilog.Events;
+using SlnMesnac.Common;
 using SlnMesnac.Config;
+using SlnMesnac.Plc;
+using SlnMesnac.Plc.Impl;
 using SlnMesnac.Quartz;
 using SlnMesnac.Repository;
 using SlnMesnac.Serilog;
@@ -72,6 +75,9 @@ namespace SlnMesnac
 
             });
 
+            //注册通用类
+            services.AddCommonSetup();
+
             //注册SqlSugar
             services.AddSqlSugarSetup();
 
@@ -80,6 +86,9 @@ namespace SlnMesnac
 
             //注册任务调度
             services.AddQuartzSetUp();
+
+            //注册PLC
+            services.AddPlcSetup();
         }
 
         /// <summary>