Inspection/PLC/PlcLibrary/OmronCipNet.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.ComponentModel.Composition;
using PLCCommunication;
using System.Net;
using PLCCommunication.PLCType.Omron;

namespace PLC
{
    /// <summary>
    /// 
    /// </summary>
    [Export("OmronCipNet", typeof(PlcReadWriteBase))]
    public class OmronCipNet : PlcReadWriteBase
    {
        private PLCCommunication.PLCType.Omron.OmronCipNet omronCipNet = null;


        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="pid"></param>
        /// <param name="pname"></param>
        /// <param name="iep"></param>
        /// <param name="timeout"></param>
        public OmronCipNet(int pid, string pname, IPEndPoint iep, int timeout = 10) :
            base(pid, pname, iep, timeout)
        {
            omronCipNet = new PLCCommunication.PLCType.Omron.OmronCipNet();
            omronCipNet.IpAddress = iep.Address.ToString();
            omronCipNet.Port = iep.Port;
            omronCipNet.Slot = (byte)0;
            omronCipNet.SocketKeepAliveTime = 60000;
            omronCipNet.ConnectTimeOut = 1000;
            omronCipNet.ReceiveTimeOut = 1000;

            IsConnected = false;
        }

        /// <summary>
        /// 启动与PLC链接
        /// </summary>
        /// <returns></returns>
        public override bool Connect(ref string msg)
        {
            bool res = false;
            try
            {
                if (!IsConnected)
                {
                    omronCipNet.ConnectClose();
                    JYResult connect = omronCipNet.ConnectServer();
                    if (connect.IsSuccess)
                    {
                        IsConnected = connect.IsSuccess;

                        msg = StringResources.Language.ConnectedSuccess;
                        return true;
                    }
                }
                else
                {
                    return true;
                }
            }
            catch (Exception ex)
            {
                msg = ex.Message;
            }
            return res;
        }

        /// <summary>
        /// 断开与PLC链接
        /// </summary>
        /// <returns></returns>
        public override bool Disconnect()
        {
            if (IsConnected)
            {
                JYResult connect = omronCipNet.ConnectClose();
                IsConnected = false;
                return connect.IsSuccess;
            }
            else
            {
                return true;
            }
        }


        /// <summary>
        /// 读取BOOl变量
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public override bool ReadBool(string address)
        {
            JYResult<bool[]> result = omronCipNet.ReadBool(address, 1);
            if (result.IsSuccess)
                return result.Content[0];
            else
                return false;

        }

        /// <summary>
        /// 读取16位整数
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public override short ReadInt16(string address)
        {

            short result = 0;
            try
            {
                if (IsConnected)
                {
                    result = omronCipNet.ReadInt16(address).Content;

                }
            }
            catch (Exception ex)
            {

            }
            return result;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public override Task<JYResult<short>> ReadInt16Async(string address)
        {
            JYResult<short> result = null;
            try
            {
                if (IsConnected)
                {
                    result = omronCipNet.ReadInt16Async(address).Result;
                }
            }
            catch (Exception ex)
            {

            }
            return Task.FromResult(result);
        }

        /// <summary>
        /// 读取32位整数
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public override int ReadInt32(string address)
        {
            int result = 0;
            try
            {
                if (IsConnected)
                {
                    result = omronCipNet.ReadInt32(address).Content;
                }
            }
            catch (Exception ex)
            {

            }
            return result;
        }

        /// <summary>
        /// 异步读取32位整数
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public override Task<JYResult<int>> ReadInt32Async(string address)
        {
            JYResult<int> result = null;
            try
            {
                if (IsConnected)
                {
                    result = omronCipNet.ReadInt32Async(address).Result;
                }
            }
            catch (Exception ex)
            {

            }
            return Task.FromResult(result);
        }

        /// <summary>
        /// 读取Float单精度小数
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public override float ReadFloat(string address)
        {
            try
            {
                JYResult<float> result = omronCipNet.ReadFloat(address);
                if (result.IsSuccess)
                {
                    return result.Content;
                }
            }
            catch (Exception)
            {

            }

            return 0.0f;


        }

        /// <summary>
        /// 读取浮点数组
        /// </summary>
        /// <param name="address"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public override float[] ReadArrFloat(string address, ushort length)
        {
            float[] floats = new float[length];
            try
            {
                JYResult<float[]> result = omronCipNet.ReadFloat(address, length);
                if (result.IsSuccess)
                {
                    floats = result.Content;
                }
            }
            catch (Exception)
            {
            }
            return floats;
        }

        /// <summary>
        /// 读取PLC数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="address"></param>
        /// <param name="type"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public override T ReadValue<T>(string address, DataType type, ushort length = 0)
        {
            object obj = default(object);
            try
            {
                switch (type)
                {
                    case DataType.Bool:
                        obj = omronCipNet.ReadBool(address);
                        break;
                    case DataType.Short:
                        obj = omronCipNet.ReadInt16(address);
                        break;
                    case DataType.Int:
                        obj = omronCipNet.ReadInt32(address);
                        break;
                    case DataType.Float:
                        obj = omronCipNet.ReadFloat(address);
                        break;
                    case DataType.Double:
                        obj = omronCipNet.ReadDouble(address);
                        break;
                    case DataType.String:
                        obj = omronCipNet.ReadString(address, length);
                        break;
                    case DataType.ArrByte:
                        obj = omronCipNet.Read(address, length);
                        break;
                    case DataType.ArrFloat:
                        obj = omronCipNet.ReadFloat(address, length);
                        //obj = ReadArrFloat(address, length);
                        break;
                    case DataType.ArrShort:
                        obj = omronCipNet.ReadInt16(address, length);
                        break;
                    case DataType.ArrUshort:
                        obj = omronCipNet.ReadUInt16(address, length);
                        break;
                    case DataType.ArrInt:
                        obj = omronCipNet.ReadUInt32(address, length);
                        break;
                    case DataType.ArrUint:
                        obj = omronCipNet.ReadUInt32(address, length);
                        break;
                    default:
                        break;
                }
                return (T)obj;
            }
            catch (Exception)
            {
                return default(T);
            }
        }


        public override bool WriteBool(string address, bool value)
        {
            bool[] data = new bool[1] { value };
            JYResult result = omronCipNet.Write(address, value);
            return result.IsSuccess;
        }

        /// <summary>
        /// 写入16位整数
        /// </summary>
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        /// 
        public override bool WriteInt16(string address, short value)
        {
            JYResult result = omronCipNet.Write(address, value);
            return result.IsSuccess;
        }
        /// <summary>
        /// 写入32位整数
        /// </summary>
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public override bool WriteInt32(string address, int value)
        {
            JYResult result = omronCipNet.Write(address, value);
            return result.IsSuccess;
        }

        /// <summary>
        /// 写入浮点数
        /// </summary>
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public override bool WriteFloat(string address, float value)
        {
            JYResult result = omronCipNet.Write(address, value);
            return result.IsSuccess;
        }


        /// <summary>
        /// 写入PLC数据
        /// </summary>
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public override JYResult WriteValue(string address, object value, DataType type = DataType.Short)
        {
            JYResult result = new JYResult();
            try
            {
                switch (type)
                {
                    case DataType.Bool:
                        result = omronCipNet.Write(address, Convert.ToBoolean(value));
                        break;
                    case DataType.Short:
                        result = omronCipNet.Write(address, Convert.ToInt16(value));
                        break;
                    case DataType.Int:
                        result = omronCipNet.Write(address, Convert.ToInt32(value));
                        break;
                    case DataType.Float:
                        result = omronCipNet.Write(address, Convert.ToSingle(value));
                        break;
                    case DataType.Double:
                        result = omronCipNet.Write(address, Convert.ToDouble(value));
                        break;
                    case DataType.String:
                        result = omronCipNet.Write(address, value.ToString());
                        break;
                    case DataType.ArrShort:
                        result = omronCipNet.Write(address, value as short[]);
                        //result = omronCipNet.Write(address, new short[] { 0, 1, 1,1 });
                        break;
                    case DataType.ArrByte:
                        result = omronCipNet.Write(address, value as byte[]);
                        break;

                    default:
                        break;
                }
                return result;
            }
            catch (Exception ex)
            {
                result.IsSuccess = false;
                result.Message = ex.Message;
                return result;
            }
        }
        /// <summary>
        /// 读取16位整数
        /// </summary>
        /// <param name="address"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public override short[] ReadArrInt16(string address, ushort length)
        {
            short[] floats = new short[length];
            try
            {
                JYResult<short[]> result = omronCipNet.ReadInt16(address, length);
                if (result.IsSuccess)
                {
                    floats = result.Content;
                }
            }
            catch (Exception)
            {
            }
            return floats;
        }

        public override async Task<JYResult<short[]>> ReadArrInt16Async(string address, ushort length)
        {
            JYResult<short[]> result = new JYResult<short[]>();
            try
            {
                result = await omronCipNet.ReadInt16Async(address, length);
            }
            catch (Exception ex)
            {
                result.IsSuccess = false;
                result.Message = ex.Message;
            }
            return result;
        }

        /// <summary>
        /// 异步读取浮点数组
        /// </summary>
        /// <param name="address"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public override async Task<JYResult<float[]>> ReadArrFloatAsync(string address, ushort length)
        {
            JYResult<float[]> result = new JYResult<float[]>();
            try
            {
                result = await omronCipNet.ReadFloatAsync(address, length);
            }
            catch (Exception ex)
            {
                result.IsSuccess = false;
                result.Message = ex.Message;
            }
            return result;
        }
    }
}