DeviceCtl-1/LHY-WD-BC_MES/HelpClass/CommPLC.cs

using HslCommunication;
using HslCommunication.ModBus;
using HslCommunication.Profinet.Inovance;
using HslCommunication.Profinet.Keyence;
using HslCommunication.Profinet.Melsec;
using HslCommunication.Profinet.Siemens;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using HslCommunication.Profinet.Omron;
using System.Security.Cryptography;
using System.IO.Ports;
using System.Threading;

namespace HRT_Measure
{
    public class CommPLC 
    {
        public EnumPLCProtocolType DeviceProtocolType; 
        //网口
        public string IP ; 
        public int Port;

        public string Name = "PLC通讯";

        //串口
        public string PortName;
        public int BaudRate;
        public int DataBit;
        public int StopBit;
        public Parity Parity;
         
        //
        public bool isPLCConnected = false; 
        public CommPLC(string ip,int port,string name, EnumPLCProtocolType deviceProtocolType) 
        {
            IP = ip;
            Port = port;
            Name = name;
            DeviceProtocolType = deviceProtocolType;
            Connect();
        }
        public CommPLC(string portName, int baudRate, int dataBit, int stopBit,Parity parity, EnumPLCProtocolType deviceProtocolType,string name)
        {
            PortName = portName;
            BaudRate = baudRate;
            DataBit = dataBit;
            StopBit = stopBit;
            Parity = parity;
            DeviceProtocolType = deviceProtocolType;
            Name = name;
            Connect();
        }
        #region PLCl类型

        public ModbusTcpNet busTcpClient = null;
        
        public ModbusTcpServer ModbusTcpServer = null;
        
        public MelsecMcNet melsec = null;

        public MelsecFxSerial fxSerial = null;//3U 3G 3GA
       
        public KeyenceMcNet keyenceNet = null;
       
        public InovanceTcpNet inovanceTcp = null;
        
        
        public KeyenceNanoSerialOverTcp keyenceOverTcp = null;//keyence自带协议
        
        public OmronFinsNet omronFinTcp = null;//NJ系列

        public ModbusRtu busRtuClient = null;

        public SiemensS7Net siemensS7Net = null; 

        #endregion
        public bool Connect()
        {
            switch (DeviceProtocolType)
            {
                case EnumPLCProtocolType.Modbus串口通信:
                    busRtuClient?.Close();
                    busRtuClient = new ModbusRtu(1);
                    busRtuClient.AddressStartWithZero = true;
                    busRtuClient.DataFormat = HslCommunication.Core.DataFormat.CDAB;
                    busRtuClient.IsStringReverse = false;
                    try
                    {
                        busRtuClient.SerialPortInni(sp =>
                        {
                            sp.PortName = PortName;
                            sp.BaudRate = BaudRate;
                            sp.DataBits = DataBit;
                            sp.StopBits = StopBit == 0 ? System.IO.Ports.StopBits.None : (StopBit == 1 ? System.IO.Ports.StopBits.One : System.IO.Ports.StopBits.Two);
                            sp.Parity = Parity;
                        });
                        busRtuClient.Open();
                        isPLCConnected = busRtuClient.IsOpen();// true;
                    }
                    catch (Exception ex)
                    {
                        isPLCConnected = false;
                        MessageBox.Show("Modbus Rtu PLC连接失败 " + ex.ToString());
                    }
                    break;
                case EnumPLCProtocolType.ModbusClinet通信:
                    busTcpClient?.ConnectClose();
                    busTcpClient = new ModbusTcpNet(IP, Port, 0x01);
                    busTcpClient.AddressStartWithZero = true;
                    busTcpClient.IsStringReverse = false;
                    busTcpClient.DataFormat = HslCommunication.Core.DataFormat.ABCD;
                    try
                    {
                        OperateResult connect = busTcpClient.ConnectServer();
                        isPLCConnected = connect.IsSuccess;
                    }
                    catch (Exception)
                    {
                        isPLCConnected = false;
                    }
                    break;
                case EnumPLCProtocolType.ModbusServer通信:
                    ModbusTcpServer = new ModbusTcpServer();
                    //ModbusTcpServer.OnDataReceived += BusTcpServer_OnDataReceived;
                    ModbusTcpServer.DataFormat = HslCommunication.Core.DataFormat.CDAB;
                    ModbusTcpServer.ServerStart(Port);
                    isPLCConnected = true;
                    break;
                case EnumPLCProtocolType.三菱MC:
                    melsec = new MelsecMcNet();
                    melsec.Port = Port;
                    melsec.IpAddress = IP;
                    melsec.ConnectClose();
                    try
                    {
                        OperateResult connect = melsec.ConnectServer();
                        isPLCConnected = connect.IsSuccess;
                    }
                    catch (Exception)
                    {
                        isPLCConnected = false;
                    }
                    break;
                case EnumPLCProtocolType.三菱FX:
                    fxSerial?.Close();
                    fxSerial = new MelsecFxSerial();
                    try
                    {
                        fxSerial.SerialPortInni(sp =>
                        {
                            sp.PortName = PortName;
                            sp.BaudRate = BaudRate;
                            sp.DataBits = DataBit;
                            sp.StopBits = StopBit == 0 ? System.IO.Ports.StopBits.None : (StopBit == 1 ? System.IO.Ports.StopBits.One : System.IO.Ports.StopBits.Two);
                            sp.Parity = Parity;
                        });
                        fxSerial.Open();
                        isPLCConnected = true;
                    }
                    catch (Exception ex)
                    {
                        isPLCConnected = false;
                        MessageBox.Show("FX PLC连接失败 " + ex.ToString());
                    }
                    break;
                case EnumPLCProtocolType.基恩士KV:
                    keyenceNet = new KeyenceMcNet();
                    keyenceNet.Port = Port;
                    keyenceNet.IpAddress = IP;
                    keyenceNet.ConnectClose();
                    try
                    {
                        OperateResult connect = keyenceNet.ConnectServer();
                        isPLCConnected = connect.IsSuccess;
                    }
                    catch (Exception)
                    {
                        isPLCConnected = false;
                    }
                    break;
                case EnumPLCProtocolType.基恩士OverTcp:
                    keyenceOverTcp = new KeyenceNanoSerialOverTcp();
                    keyenceOverTcp.Port = Port;
                    keyenceOverTcp.IpAddress = IP;
                    keyenceOverTcp.ConnectClose();
                    try
                    {
                        OperateResult connect = keyenceOverTcp.ConnectServer();
                        isPLCConnected = connect.IsSuccess;
                    }
                    catch (Exception)
                    {
                        isPLCConnected = false;
                    }
                    break;
                case EnumPLCProtocolType.欧姆龙FinsTcp:
                    omronFinTcp = new OmronFinsNet();
                    omronFinTcp.Port = Port;
                    omronFinTcp.IpAddress = IP;
                    //omronFinTcp.SA1 = SA1;
                    //omronFinTcp.DA2 = DA2;
                    omronFinTcp.ByteTransform.DataFormat = HslCommunication.Core.DataFormat.CDAB;
                    omronFinTcp.ConnectClose();
                    try
                    {
                        OperateResult connect = omronFinTcp.ConnectServer();
                        isPLCConnected = connect.IsSuccess;
                    }
                    catch (Exception)
                    {
                        isPLCConnected = false;
                    }
                    break;
                case EnumPLCProtocolType.汇川H5U:
                    inovanceTcp = new InovanceTcpNet();
                    inovanceTcp.IpAddress = IP;
                    inovanceTcp.Port = Port;
                    inovanceTcp.Series = InovanceSeries.H5U;
                    inovanceTcp.DataFormat = HslCommunication.Core.DataFormat.CDAB;
                    inovanceTcp.IsStringReverse = true;
                    inovanceTcp.ConnectClose();
                    try
                    {
                        OperateResult connect = inovanceTcp.ConnectServer();
                        isPLCConnected = connect.IsSuccess;
                        ProgramHelp.Instance.SaveMsg("PLC", $"PLC：{Name} {IP}:{Port}连接成功", true);
                    }
                    catch (Exception)
                    {
                        isPLCConnected = false;
                    }
                    break;
                case EnumPLCProtocolType.西门子1200:
                    siemensS7Net = new SiemensS7Net(SiemensPLCS.S1200, IP);
                    siemensS7Net.IpAddress = IP;
                    siemensS7Net.Port = Port;
                    siemensS7Net.ConnectClose();
                    try
                    {
                        OperateResult connect = siemensS7Net.ConnectServer();
                        isPLCConnected = connect.IsSuccess;//  true;
                        ProgramHelp.Instance.SaveMsg("PLC", $"PLC：{Name} {IP}:{Port}连接成功", true);
                    }
                    catch (Exception)
                    {
                        isPLCConnected = false;
                    }
                    break;
            }
            return isPLCConnected;
        }

        public  void Close()
        {
            try
            {
                switch (DeviceProtocolType)
                {
                    case EnumPLCProtocolType.Modbus串口通信:
                        busRtuClient.Close();
                        break;
                    case EnumPLCProtocolType.ModbusClinet通信:
                        busTcpClient?.ConnectClose();
                        break;
                    case EnumPLCProtocolType.ModbusServer通信:
                        ModbusTcpServer?.ServerClose();
                        break;
                    case EnumPLCProtocolType.三菱MC:
                        melsec?.ConnectClose();
                        break;
                    case EnumPLCProtocolType.三菱FX:
                        fxSerial?.Close();
                        break;
                    case EnumPLCProtocolType.基恩士KV:
                        keyenceNet?.ConnectClose();
                        break;
                    case EnumPLCProtocolType.基恩士OverTcp:
                        keyenceOverTcp?.ConnectClose();
                        break;
                    case EnumPLCProtocolType.汇川H5U:
                        inovanceTcp?.ConnectClose();
                        break;
                    case EnumPLCProtocolType.欧姆龙FinsTcp:
                        omronFinTcp?.ConnectClose();
                        break;
                    case EnumPLCProtocolType.西门子1200:
                        siemensS7Net?.ConnectClose();
                        break;
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
            }
            isPLCConnected = false;
        }

        #region double

        public object objDouble = new object();
        public bool ReadDouble(string strAdd, out double dResult, out string strContent)
        {
            lock(objDouble)
            {
                dResult = 0;
                strContent = "";
                if (!isPLCConnected) return false;
                try
                {
                    OperateResult<double> operateResult = new OperateResult<double>();
                    switch (DeviceProtocolType)
                    {
                        case EnumPLCProtocolType.Modbus串口通信:
                            operateResult = busRtuClient.ReadDouble(strAdd);
                            break;
                        case EnumPLCProtocolType.ModbusClinet通信:
                            operateResult = busTcpClient.ReadDouble(strAdd);
                            break;
                        case EnumPLCProtocolType.ModbusServer通信:
                            operateResult = ModbusTcpServer.ReadDouble(strAdd);
                            break;
                        case EnumPLCProtocolType.三菱MC:
                            operateResult = melsec.ReadDouble(strAdd);
                            break;
                        case EnumPLCProtocolType.三菱FX:
                            operateResult = fxSerial.ReadDouble(strAdd);
                            break;
                        case EnumPLCProtocolType.基恩士KV:
                            operateResult = keyenceNet.ReadDouble(strAdd);
                            break;
                        case EnumPLCProtocolType.基恩士OverTcp:
                            operateResult = keyenceOverTcp.ReadDouble(strAdd);
                            break;
                        case EnumPLCProtocolType.汇川H5U:
                            operateResult = inovanceTcp.ReadDouble(strAdd);
                            break;
                        case EnumPLCProtocolType.欧姆龙FinsTcp:
                            operateResult = omronFinTcp.ReadDouble(strAdd);
                            break;
                        case EnumPLCProtocolType.西门子1200:
                            operateResult = siemensS7Net.ReadDouble(strAdd);
                            break;
                    }

                    if (!operateResult.IsSuccess)
                    {
                        strContent = "read err :" + operateResult.Message;
                        //MessageBox.Show($"Read Err ,地址 {strAdd} {operateResult.Message}");
                        return false;
                    }
                    dResult = operateResult.Content;
                    strContent = "read ok :" + dResult.ToString();
                    return true;
                }
                catch (Exception ex)
                {
                    strContent = ex.Message;
                    return false;
                }
            }
        }
        public  bool WriteDouble(string strAdd, double dData, out string strContent)
        {
            lock(objDouble)
            {
                strContent = "";
                if (!isPLCConnected) return false;
                try
                {
                    OperateResult operateResult = new OperateResult();
                    switch (DeviceProtocolType)
                    {
                        case EnumPLCProtocolType.Modbus串口通信:
                            operateResult = busRtuClient.Write(strAdd, dData);
                            break;
                        case EnumPLCProtocolType.ModbusClinet通信:
                            operateResult = busTcpClient.Write(strAdd, dData);
                            break;
                        case EnumPLCProtocolType.ModbusServer通信:
                            operateResult = ModbusTcpServer.Write(strAdd, dData);
                            break;
                        case EnumPLCProtocolType.三菱MC:
                            operateResult = melsec.Write(strAdd, dData);
                            break;
                        case EnumPLCProtocolType.三菱FX:
                            operateResult = fxSerial.Write(strAdd, dData);
                            break;
                        case EnumPLCProtocolType.基恩士KV:
                            operateResult = keyenceNet.Write(strAdd, dData);
                            break;
                        case EnumPLCProtocolType.基恩士OverTcp:
                            operateResult = keyenceOverTcp.Write(strAdd, dData);
                            break;
                        case EnumPLCProtocolType.汇川H5U:
                            inovanceTcp.Write(strAdd, dData);
                            break;
                        case EnumPLCProtocolType.欧姆龙FinsTcp:
                            operateResult = omronFinTcp.Write(strAdd, dData);
                            break;
                        case EnumPLCProtocolType.西门子1200:
                            operateResult = siemensS7Net.Write(strAdd, dData);
                            break;
                    }
                    if (!operateResult.IsSuccess)
                    {
                        strContent = "write err :" + operateResult.Message;
                        //MessageBox.Show($"Write err, 地址 {strAdd} {operateResult.Message}");
                        return false;
                    }
                    strContent = "WriteSuccess " + operateResult.Message;
                    return true;
                }
                catch (Exception ex)
                {
                    strContent = ex.Message;
                    return false;
                }
            }
        }

        #endregion

        #region float
        public object objFloat = new object();
        public bool ReadFloat(string strAdd, out float dResult, out string strContent)
        {
            lock(objFloat)
            {
                dResult = 0;
                strContent = "";
                if (!isPLCConnected) return false;
                try
                {
                    OperateResult<float> operateResult = new OperateResult<float>();
                    switch (DeviceProtocolType)
                    {
                        case EnumPLCProtocolType.Modbus串口通信:
                            operateResult = busRtuClient.ReadFloat(strAdd);
                            break;
                        case EnumPLCProtocolType.ModbusClinet通信:
                            operateResult = busTcpClient.ReadFloat(strAdd);
                            break;
                        case EnumPLCProtocolType.ModbusServer通信:
                            operateResult = ModbusTcpServer.ReadFloat(strAdd);
                            break;
                        case EnumPLCProtocolType.三菱MC:
                            operateResult = melsec.ReadFloat(strAdd);
                            break;
                        case EnumPLCProtocolType.三菱FX:
                            operateResult = fxSerial.ReadFloat(strAdd);
                            break;
                        case EnumPLCProtocolType.基恩士KV:
                            operateResult = keyenceNet.ReadFloat(strAdd);
                            break;
                        case EnumPLCProtocolType.基恩士OverTcp:
                            operateResult = keyenceOverTcp.ReadFloat(strAdd);
                            break;
                        case EnumPLCProtocolType.汇川H5U:
                            operateResult = inovanceTcp.ReadFloat(strAdd);
                            break;
                        case EnumPLCProtocolType.欧姆龙FinsTcp:
                            operateResult = omronFinTcp.ReadFloat(strAdd);
                            break;
                        case EnumPLCProtocolType.西门子1200:
                            operateResult = siemensS7Net.ReadFloat(strAdd);
                            break;
                    }

                    if (!operateResult.IsSuccess)
                    {
                        strContent = "read err :" + operateResult.Message;
                        //MessageBox.Show($"Read Err ,地址 {strAdd} {operateResult.Message}");
                        return false;
                    }
                    dResult = operateResult.Content;
                    strContent = "read ok :" + dResult.ToString();
                    return true;
                }
                catch (Exception ex)
                {
                    strContent = ex.Message;
                    return false;
                }
            }
        }
        public bool WriteFloat(string strAdd, float fData, out string strContent)
        {
            lock(objFloat)
            {
                try
                {
                    strContent = "";
                    if (!isPLCConnected) return false;
                    OperateResult operateResult = new OperateResult();
                    switch (DeviceProtocolType)
                    {
                        case EnumPLCProtocolType.Modbus串口通信:
                            operateResult = busRtuClient.Write(strAdd, fData);
                            break;
                        case EnumPLCProtocolType.ModbusClinet通信:
                            operateResult = busTcpClient.Write(strAdd, fData);
                            break;
                        case EnumPLCProtocolType.ModbusServer通信:
                            operateResult = ModbusTcpServer.Write(strAdd, fData);
                            break;
                        case EnumPLCProtocolType.三菱MC:
                            operateResult = melsec.Write(strAdd, fData);
                            break;
                        case EnumPLCProtocolType.三菱FX:
                            operateResult = fxSerial.Write(strAdd, fData);
                            break;
                        case EnumPLCProtocolType.基恩士KV:
                            operateResult = keyenceNet.Write(strAdd, fData);
                            break;
                        case EnumPLCProtocolType.基恩士OverTcp:
                            operateResult = keyenceOverTcp.Write(strAdd, fData);
                            break;
                        case EnumPLCProtocolType.汇川H5U:
                            inovanceTcp.Write(strAdd, fData);
                            break;
                        case EnumPLCProtocolType.欧姆龙FinsTcp:
                            omronFinTcp.Write(strAdd, fData);
                            break;
                        case EnumPLCProtocolType.西门子1200:
                            operateResult = siemensS7Net.Write(strAdd, fData);
                            break;
                    }
                    if (!operateResult.IsSuccess)
                    {
                        strContent = "write err :" + operateResult.Message;
                        MessageBox.Show($"Write err, 地址 {strAdd} {operateResult.Message}");
                        return false;
                    }
                    strContent = "WriteSuccess " + operateResult.Message;
                    return true;
                }
                catch (Exception ex)
                {
                    strContent = ex.Message;
                    return false;
                }
            }
        }

        #endregion

        #region int

        public object objInt = new object();
        public bool ReadInt(string strAdd, out int iResult, out string strContent)
        {
            lock(objInt)
            {
                iResult = 0;
                strContent = "";
                if (!isPLCConnected) return false;
                try
                {
                    OperateResult<int> operateResult = new OperateResult<int>();
                    switch (DeviceProtocolType)
                    {
                        case EnumPLCProtocolType.Modbus串口通信:
                            operateResult = busRtuClient.ReadInt32(strAdd);
                            break;
                        case EnumPLCProtocolType.ModbusClinet通信:
                            operateResult = busTcpClient.ReadInt32(strAdd);
                            break;
                        case EnumPLCProtocolType.ModbusServer通信:
                            operateResult = ModbusTcpServer.ReadInt32(strAdd);
                            break;
                        case EnumPLCProtocolType.三菱MC:
                            operateResult = melsec.ReadInt32(strAdd);
                            break;
                        case EnumPLCProtocolType.三菱FX:
                            operateResult = fxSerial.ReadInt32(strAdd);
                            break;
                        case EnumPLCProtocolType.基恩士KV:
                            operateResult = keyenceNet.ReadInt32(strAdd);
                            break;
                        case EnumPLCProtocolType.基恩士OverTcp:
                            operateResult = keyenceOverTcp.ReadInt32(strAdd);
                            break;
                        case EnumPLCProtocolType.汇川H5U:
                            operateResult = inovanceTcp.ReadInt32(strAdd);  
                            
                            break;
                        case EnumPLCProtocolType.欧姆龙FinsTcp:
                            operateResult = omronFinTcp.ReadInt32(strAdd);
                            break;
                        case EnumPLCProtocolType.西门子1200:
                            operateResult = siemensS7Net.ReadInt32(strAdd);
                            break;
                    }
                    if (!operateResult.IsSuccess)
                    {
                        strContent = "read err :" + operateResult.Message;
                        //MessageBox.Show($"Read Err ,地址 {strAdd} {operateResult.Message}");
                        return false;
                    }
                    iResult = operateResult.Content;
                    strContent = "read ok :" + iResult.ToString();
                    return true;
                }
                catch (Exception ex)
                {
                    strContent = ex.Message;
                    return false;
                }
            }
        }
        public bool WriteInt(string strAdd, int iData, out string strContent)
        {
            lock(objInt)
            {
                try
                {
                    strContent = "";
                    if (!isPLCConnected) return false;
                    OperateResult operateResult = new OperateResult();
                    switch (DeviceProtocolType)
                    {
                        case EnumPLCProtocolType.Modbus串口通信:
                            operateResult = busRtuClient.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.ModbusClinet通信:
                            operateResult = busTcpClient.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.ModbusServer通信:
                            operateResult = ModbusTcpServer.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.三菱MC:
                            operateResult = melsec.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.三菱FX:
                            operateResult = fxSerial.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.基恩士KV:
                            operateResult = keyenceNet.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.基恩士OverTcp:
                            operateResult = keyenceOverTcp.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.汇川H5U:
                            operateResult = inovanceTcp.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.欧姆龙FinsTcp:
                            operateResult = omronFinTcp.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.西门子1200:
                            operateResult = siemensS7Net.Write(strAdd, iData);
                            break;
                    }
                    if (!operateResult.IsSuccess)
                    {
                        strContent = "write err :" + operateResult.Message;
                        //MessageBox.Show($"Write err, 地址 {strAdd} {operateResult.Message}");
                        return false;
                    }
                    strContent = "WriteSuccess " + operateResult.Message;
                    return true;
                }
                catch (Exception ex)
                {
                    strContent = ex.Message;
                    return false;
                }
            }
        }

        #endregion

        #region Dint

        public object objDInt = new object();
        public bool ReadInt64(string strAdd, out Int64 iResult, out string strContent)
        {
            lock (objDInt)
            { 
                iResult = 0;
                strContent = "";
                if (!isPLCConnected) return false;
                try
                {
                    OperateResult<Int64> operateResult = new OperateResult<Int64>();
                    switch (DeviceProtocolType)
                    {
                        case EnumPLCProtocolType.Modbus串口通信:
                            operateResult = busRtuClient.ReadInt64(strAdd);
                            break;
                        case EnumPLCProtocolType.ModbusClinet通信:
                            operateResult = busTcpClient.ReadInt64(strAdd);
                            break;
                        case EnumPLCProtocolType.ModbusServer通信:
                            operateResult = ModbusTcpServer.ReadInt64(strAdd);
                            break;
                        case EnumPLCProtocolType.三菱MC:
                            operateResult = melsec.ReadInt64(strAdd);
                            break;
                        case EnumPLCProtocolType.三菱FX:
                            operateResult = fxSerial.ReadInt64(strAdd);
                            break;
                        case EnumPLCProtocolType.基恩士KV:
                            operateResult = keyenceNet.ReadInt64(strAdd);
                            break;
                        case EnumPLCProtocolType.基恩士OverTcp:
                            operateResult = keyenceOverTcp.ReadInt64(strAdd);
                            break;
                        case EnumPLCProtocolType.汇川H5U:
                            operateResult = inovanceTcp.ReadInt64(strAdd);

                            break;
                        case EnumPLCProtocolType.欧姆龙FinsTcp:
                            operateResult = omronFinTcp.ReadInt64(strAdd);
                            break;
                        case EnumPLCProtocolType.西门子1200:
                            operateResult = siemensS7Net.ReadInt64(strAdd);
                            break;
                    }
                    if (!operateResult.IsSuccess)
                    {
                        strContent = "read err :" + operateResult.Message;
                        //MessageBox.Show($"Read Err ,地址 {strAdd} {operateResult.Message}");
                        return false;
                    }
                    iResult = operateResult.Content;
                    strContent = "read ok :" + iResult.ToString();
                    return true;
                }
                catch (Exception ex)
                {
                    strContent = ex.Message;
                    return false;
                }
            }
        }
        public bool WriteInt64(string strAdd, Int64 iData, out string strContent)
        {
            lock (objDInt)
            {
                try
                {
                    strContent = "";
                    if (!isPLCConnected) return false;
                    OperateResult operateResult = new OperateResult();
                    switch (DeviceProtocolType)
                    {
                        case EnumPLCProtocolType.Modbus串口通信:
                            operateResult = busRtuClient.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.ModbusClinet通信:
                            operateResult = busTcpClient.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.ModbusServer通信:
                            operateResult = ModbusTcpServer.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.三菱MC:
                            operateResult = melsec.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.三菱FX:
                            operateResult = fxSerial.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.基恩士KV:
                            operateResult = keyenceNet.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.基恩士OverTcp:
                            operateResult = keyenceOverTcp.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.汇川H5U:
                            operateResult = inovanceTcp.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.欧姆龙FinsTcp:
                            operateResult = omronFinTcp.Write(strAdd, iData);
                            break;
                        case EnumPLCProtocolType.西门子1200:
                            operateResult = siemensS7Net.Write(strAdd, iData);
                            break;
                    }
                    if (!operateResult.IsSuccess)
                    {
                        strContent = "write err :" + operateResult.Message;
                        //MessageBox.Show($"Write err, 地址 {strAdd} {operateResult.Message}");
                        return false;
                    }
                    strContent = "WriteSuccess " + operateResult.Message;
                    return true;
                }
                catch (Exception ex)
                {
                    strContent = ex.Message;
                    return false;
                }
            }
        }

        #endregion

        #region short
        public object objShort = new object();

        public bool WriteShort(string strAdd, short iResult, out string strContent)
        {
            lock(objShort)
            {
                try
                {
                    strContent = "";
                    if (!isPLCConnected) return false;
                    OperateResult operateResult = new OperateResult();
                    switch (DeviceProtocolType)
                    {
                        case EnumPLCProtocolType.Modbus串口通信:
                            operateResult = busRtuClient.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.ModbusClinet通信:
                            operateResult = busTcpClient.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.ModbusServer通信:
                            operateResult = ModbusTcpServer.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.三菱MC:
                            operateResult = melsec.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.三菱FX:
                            operateResult = fxSerial.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.基恩士KV:
                            operateResult = keyenceNet.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.基恩士OverTcp:
                            operateResult = keyenceOverTcp.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.汇川H5U:
                            operateResult = inovanceTcp.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.欧姆龙FinsTcp:
                            operateResult = omronFinTcp.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.西门子1200:
                            operateResult = siemensS7Net.Write(strAdd, iResult);
                            break;
                    }
                    if (!operateResult.IsSuccess)
                    {
                        strContent = "write err :" + operateResult.Message;
                        //MessageBox.Show($"Write err, 地址 {strAdd} {operateResult.Message}");
                        return false;
                    }
                    strContent = "WriteSuccess " + operateResult.Message;
                    return true;
                }
                catch (Exception ex)
                {
                    strContent = ex.Message;
                    return false;
                }
            }
        }
        public bool ReadShort(string strAdd, out short iResult, out string strContent)
        {
            lock(objShort)
            {
                iResult = 0;
                strContent = "";
                if (!isPLCConnected) return false;
                try
                {
                    OperateResult<short> operateResult = new OperateResult<short>();
                    switch (DeviceProtocolType)
                    {
                        case EnumPLCProtocolType.Modbus串口通信:
                            operateResult = busRtuClient.ReadInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.ModbusClinet通信:
                            operateResult = busTcpClient.ReadInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.ModbusServer通信:
                            operateResult = ModbusTcpServer.ReadInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.三菱MC:
                            operateResult = melsec.ReadInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.三菱FX:
                            operateResult = fxSerial.ReadInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.基恩士KV:
                            operateResult = keyenceNet.ReadInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.基恩士OverTcp:
                            operateResult = keyenceOverTcp.ReadInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.汇川H5U:
                            operateResult = inovanceTcp.ReadInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.欧姆龙FinsTcp:
                            operateResult = omronFinTcp.ReadInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.西门子1200:
                            operateResult = siemensS7Net.ReadInt16(strAdd);
                            break;
                    }
                    if (!operateResult.IsSuccess)
                    {
                        strContent = "read err :" + operateResult.Message;
                        //MessageBox.Show($"Read Err ,地址 {strAdd} {operateResult.Message}");
                        return false;
                    }
                    iResult = operateResult.Content;
                    strContent = "read ok :" + iResult.ToString();
                    return true;
                }
                catch (Exception ex)
                {
                    strContent = ex.Message;
                    return false;
                }
            }
        }

        #endregion

        #region ushort
        public object objUshort = new object();
        public bool WriteUShort(string strAdd, ushort iResult, out string strContent)
        {
            lock(objUshort)
            {
                try
                {
                    strContent = "";
                    if (!isPLCConnected) return false;
                    OperateResult operateResult = new OperateResult();
                    switch (DeviceProtocolType)
                    {
                        case EnumPLCProtocolType.Modbus串口通信:
                            operateResult = busRtuClient.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.ModbusClinet通信:
                            operateResult = busTcpClient.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.ModbusServer通信:
                            operateResult = ModbusTcpServer.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.三菱MC:
                            operateResult = melsec.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.三菱FX:
                            operateResult = fxSerial.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.基恩士KV:
                            operateResult = keyenceNet.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.基恩士OverTcp:
                            operateResult = keyenceOverTcp.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.汇川H5U:
                            operateResult = inovanceTcp.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.欧姆龙FinsTcp:
                            operateResult = omronFinTcp.Write(strAdd, iResult);
                            break;
                        case EnumPLCProtocolType.西门子1200:
                            operateResult = siemensS7Net.Write(strAdd, iResult);
                            break;
                    }
                    if (!operateResult.IsSuccess)
                    {
                        strContent = "write err :" + operateResult.Message;
                        //MessageBox.Show($"Write err, 地址 {strAdd} {operateResult.Message}");
                        return false;
                    }
                    strContent = "WriteSuccess " + operateResult.Message;
                    return true;
                }
                catch (Exception ex)
                {
                    strContent = ex.Message;
                    return false;
                }
            }
        }
        public  bool ReadUshort(string strAdd, out ushort iResult, out string strContent)
        {
            lock(objUshort)
            {
                iResult = 0;
                strContent = "";
                if (!isPLCConnected) return false;
                try
                {
                    OperateResult<ushort> operateResult = new OperateResult<ushort>();
                    switch (DeviceProtocolType)
                    {
                        case EnumPLCProtocolType.Modbus串口通信:
                            operateResult = busRtuClient.ReadUInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.ModbusClinet通信:
                            operateResult = busTcpClient.ReadUInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.ModbusServer通信:
                            operateResult = ModbusTcpServer.ReadUInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.三菱MC:
                            operateResult = melsec.ReadUInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.三菱FX:
                            operateResult = fxSerial.ReadUInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.基恩士KV:
                            operateResult = keyenceNet.ReadUInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.基恩士OverTcp:
                            operateResult = keyenceOverTcp.ReadUInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.汇川H5U:
                            operateResult = inovanceTcp.ReadUInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.欧姆龙FinsTcp:
                            operateResult = omronFinTcp.ReadUInt16(strAdd);
                            break;
                        case EnumPLCProtocolType.西门子1200:
                            operateResult = siemensS7Net.ReadUInt16(strAdd);
                            break;
                    }
                    if (!operateResult.IsSuccess)
                    {
                        strContent = "read err :" + operateResult.Message;
                        //MessageBox.Show($"Read Err ,地址 {strAdd} {operateResult.Message}");
                        return false;
                    }
                    iResult = operateResult.Content;
                    strContent = "read ok :" + iResult.ToString();
                    return true;
                }
                catch (Exception ex)
                {
                    strContent = ex.Message;
                    return false;
                }
            }
        }

        #endregion

        #region string
        public object objString = new object();
        public bool ReadString(string strAdd, out string strResult, out string strContent)
        {
            lock(objString)
            {
                strResult = "";
                strContent = "";
                if (!isPLCConnected) return false;
                try
                {
                    OperateResult<string> operateResult = new OperateResult<string>();
                    switch (DeviceProtocolType)
                    {
                        case EnumPLCProtocolType.Modbus串口通信:
                            operateResult = busRtuClient.ReadString(strAdd, 10);
                            break;
                        case EnumPLCProtocolType.ModbusClinet通信:
                            operateResult = busTcpClient.ReadString(strAdd, 10);
                            break;
                        case EnumPLCProtocolType.ModbusServer通信:
                            operateResult = ModbusTcpServer.ReadString(strAdd, 10);
                            break;
                        case EnumPLCProtocolType.三菱MC:
                            operateResult = melsec.ReadString(strAdd, 10);
                            break;
                        case EnumPLCProtocolType.三菱FX:
                            operateResult = fxSerial.ReadString(strAdd, 10);
                            break;
                        case EnumPLCProtocolType.基恩士KV:
                            operateResult = keyenceNet.ReadString(strAdd, 10);
                            break;
                        case EnumPLCProtocolType.基恩士OverTcp:
                            operateResult = keyenceOverTcp.ReadString(strAdd, 10);
                            break;
                        case EnumPLCProtocolType.汇川H5U:
                            operateResult = inovanceTcp.ReadString(strAdd, 10);
                            break;
                        case EnumPLCProtocolType.欧姆龙FinsTcp:
                            operateResult = omronFinTcp.ReadString(strAdd, 10);
                            break;
                        case EnumPLCProtocolType.西门子1200:
                            operateResult = siemensS7Net.ReadString(strAdd, 10);
                            break;
                    }
                    if (!operateResult.IsSuccess)
                    {
                        strContent = "read err :" + operateResult.Message;
                        //MessageBox.Show($"Read Err ,地址 {strAdd} {operateResult.Message}");
                        return false;
                    }
                    strResult = operateResult.Content;
                    strContent = "read ok :" + strResult;
                    return true;
                }
                catch (Exception ex)
                {
                    strContent = ex.Message;
                    return false;
                }
            }
        }
        public  bool WriteString(string strAdd, string strData, out string strContent)
        {
            lock(objString)
            {
                try
                {
                    strContent = "";
                    if (!isPLCConnected) return false;
                    OperateResult operateResult = new OperateResult();
                    switch (DeviceProtocolType)
                    {
                        case EnumPLCProtocolType.Modbus串口通信:
                            operateResult = busRtuClient.Write(strAdd, strData);
                            break;
                        case EnumPLCProtocolType.ModbusClinet通信:
                            operateResult = busTcpClient.Write(strAdd, strData);
                            break;
                        case EnumPLCProtocolType.ModbusServer通信:
                            operateResult = ModbusTcpServer.Write(strAdd, strData);
                            break;
                        case EnumPLCProtocolType.三菱MC:
                            operateResult = melsec.Write(strAdd, strData);
                            break;
                        case EnumPLCProtocolType.三菱FX:
                            operateResult = fxSerial.Write(strAdd, strData);
                            break;
                        case EnumPLCProtocolType.基恩士KV:
                            operateResult = keyenceNet.Write(strAdd, strData);
                            break;
                        case EnumPLCProtocolType.基恩士OverTcp:
                            operateResult = keyenceOverTcp.Write(strAdd, strData);
                            break;
                        case EnumPLCProtocolType.汇川H5U:
                            operateResult = inovanceTcp.Write(strAdd, strData, Encoding.ASCII);
                            break;
                        case EnumPLCProtocolType.欧姆龙FinsTcp:
                            operateResult = omronFinTcp.Write(strAdd, strData);
                            break;
                        case EnumPLCProtocolType.西门子1200:
                            operateResult = siemensS7Net.Write(strAdd, strData);
                            break;
                    }
                    if (!operateResult.IsSuccess)
                    {
                        strContent = "write err :" + operateResult.Message;
                        //MessageBox.Show($"Write err, 地址 {strAdd} {operateResult.Message}");
                        return false;
                    }
                    strContent = "WriteSuccess " + operateResult.Message;
                    return true;
                }
                catch (Exception ex)
                {
                    strContent = ex.Message;
                    return false;
                }
            }
        }

        #endregion

        #region Coin
        public object objBool = new object();
        public bool ReadCoin(string strAdd, out bool bResult, out string strContent)
        {
            lock(objBool)
            {
                bResult = false;
                strContent = "";
                if (!isPLCConnected) return false;
                try
                {
                    OperateResult<bool> operateResult = new OperateResult<bool>();
                    switch (DeviceProtocolType)
                    {
                        case EnumPLCProtocolType.Modbus串口通信:
                            operateResult = busRtuClient.ReadCoil(strAdd);
                            break;
                        case EnumPLCProtocolType.ModbusClinet通信:
                            operateResult = busTcpClient.ReadCoil(strAdd);
                            break;
                        case EnumPLCProtocolType.ModbusServer通信:
                            operateResult = ModbusTcpServer.ReadBool(strAdd);
                            break;
                        case EnumPLCProtocolType.三菱MC:
                            operateResult = melsec.ReadBool(strAdd);
                            break;
                        case EnumPLCProtocolType.三菱FX:
                            operateResult = fxSerial.ReadBool(strAdd);
                            break;
                        case EnumPLCProtocolType.基恩士KV:
                            operateResult = keyenceNet.ReadBool(strAdd);
                            break;
                        case EnumPLCProtocolType.基恩士OverTcp:
                            operateResult = keyenceOverTcp.ReadBool(strAdd);
                            break;
                        case EnumPLCProtocolType.汇川H5U:
                            operateResult = inovanceTcp.ReadCoil(strAdd);
                            break;
                        case EnumPLCProtocolType.欧姆龙FinsTcp:
                            operateResult = omronFinTcp.ReadBool(strAdd);
                            break;
                        case EnumPLCProtocolType.西门子1200:
                            operateResult = siemensS7Net.ReadBool(strAdd);
                            break;
                    }
                    if (!operateResult.IsSuccess)
                    {
                        strContent = "read err :" + operateResult.Message;
                        //MessageBox.Show($"Read Err ,地址 {strAdd} {operateResult.Message}");
                        return false;
                    }
                    bResult = operateResult.Content;
                    strContent = "read ok :" + bResult;
                    return true;
                }
                catch (Exception ex)
                {
                    strContent = ex.Message;
                    return false;
                }
            }
        }

        public bool WriteCoin(string strAdd, bool isOn, out string strContent)
        {
            lock(objBool)
            {
                try
                {
                    strContent = "";
                    if (!isPLCConnected) return false;
                    OperateResult operateResult = new OperateResult();
                    switch (DeviceProtocolType)
                    {
                        case EnumPLCProtocolType.Modbus串口通信:
                            operateResult = busRtuClient.Write(strAdd, isOn);
                            break;
                        case EnumPLCProtocolType.ModbusClinet通信:
                            operateResult = busTcpClient.Write(strAdd, isOn);
                            break;
                        case EnumPLCProtocolType.ModbusServer通信:
                            operateResult = ModbusTcpServer.Write(strAdd, isOn);
                            break;
                        case EnumPLCProtocolType.三菱MC:
                            operateResult = melsec.Write(strAdd, isOn);
                            break;
                        case EnumPLCProtocolType.三菱FX:
                            operateResult = fxSerial.Write(strAdd, isOn);
                            break;
                        case EnumPLCProtocolType.基恩士KV:
                            operateResult = keyenceNet.Write(strAdd, isOn);
                            break;
                        case EnumPLCProtocolType.基恩士OverTcp:
                            operateResult = keyenceOverTcp.Write(strAdd, isOn);
                            break;
                        case EnumPLCProtocolType.汇川H5U:
                            operateResult = inovanceTcp.Write(strAdd, isOn);
                            break;
                        case EnumPLCProtocolType.欧姆龙FinsTcp:
                            operateResult = omronFinTcp.Write(strAdd, isOn);
                            break;
                        case EnumPLCProtocolType.西门子1200:
                            operateResult = siemensS7Net.Write(strAdd, isOn);
                            break;
                    }
                    if (!operateResult.IsSuccess)
                    {
                        strContent = "write err :" + operateResult.Message;
                        //MessageBox.Show($"Write err, 地址 {strAdd} {operateResult.Message}");
                        return false;
                    }
                    strContent = "WriteSuccess " + operateResult.Message;
                    return true;
                }
                catch (Exception ex)
                {
                    strContent = ex.Message;
                    return false;
                }
            }
        }
        #endregion
    }
}