Mars200/JetMainframe/Devices/FinsTcpPlc.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using MECF.Framework.Common.Event;
using MECF.Framework.Common.PLC;
using MECF.Framework.RT.Core.IoProviders.Common;
using MECF.Framework.RT.Core.IoProviders.Common.Transfer;
using MECF.Framework.RT.Core.IoProviders.Omron;

namespace JetMainframe.Devices
{
    public class FinsTcpPlc : IPlc
    {
        private OmronFinsNet omronFinsNet = null;

        private bool _isOpened = false;

        private string _ip = "192.168.10.10";
        private string _localIp = "192.168.10.199";
        private int _port = 9600;

        private int _aoBlockStartPosition = 1000;
        private int _aiBlockStartPosition = 2000;
        private int _doBlockStartPosition = 0;
        private int _diBlockStartPosition = 20;
        
        R_TRIG _failedTrigger = new R_TRIG();

        DeviceTimer _timerWrite = new DeviceTimer();
        DeviceTimer _timerRead = new DeviceTimer();

        private double _averageWriteTime = 0;
        private double _averageReadTime = 0;

        public FinsTcpPlc(string ip, int port,string localIp)
        {
            _ip = ip;
            _port = port;
            _localIp = localIp;
        }
        
        private void RaiseException(string p)
        {

            _isOpened = false;
        }
        
        public event Action<string, AlarmEventItem> OnDeviceAlarmStateChanged;

        public string Module { get; set; }

        public string Name { get; set; }

        public bool HasAlarm { get; }

        public bool Initialize()
        {
            throw new NotImplementedException();
        }

        public void Monitor()
        {
            throw new NotImplementedException();
        }

        public void Terminate()
        {
            throw new NotImplementedException();
        }

        public void Reset()
        {
            throw new NotImplementedException();
        }

        public string Address { get; }

        public bool IsConnected
        {
            get
            {  if (omronFinsNet == null)
                    return false;
                return omronFinsNet.IsConnected; ;
            }
        }

        public bool Connect()
        {
            try
            {
                LOG.Write(String.Format("试图连接PLC {0}:{1}", _ip, _port));

                _isOpened = false;

                omronFinsNet = new OmronFinsNet(_ip, _port, _localIp){ConnectTimeOut = 1000,ReceiveTimeOut = 1000};

                OperateResult connect = omronFinsNet.ConnectServer();
                if (connect.IsSuccess)
                {
                    _isOpened = true;
                }

            }
            catch (Exception ex)
            {
                _failedTrigger.CLK = true;

                if (_failedTrigger.Q)
                {
                    LOG.Write(ex, String.Format("Communication failed with PLC {0}:{1}", _ip, _port));
                    EV.PostMessage("System", EventEnum.DefaultWarning, String.Format("Communication failed with PLC {0}:{1}", _ip, _port));
                }

                return false;
            }

            _failedTrigger.RST = true;

            return true;
        }

        public bool Disconnect()
        {
            try
            {
                if (_isOpened)
                {
                    _isOpened = false;
                    omronFinsNet.ConnectClose();
                }

            }
            catch (Exception ex)
            {
                LOG.Write(ex);
            }

            return true;
        }

        public AlarmEventItem AlarmConnectFailed { get; set; }
        public AlarmEventItem AlarmCommunicationError { get; set; }
        public event Action OnConnected;
        public event Action OnDisconnected;
        public bool CheckIsConnected()
        {
            if (omronFinsNet == null)
                return false;
            return omronFinsNet.IsConnected;
        }

        public bool Read(string variable, out object data, string type, int length, out string reason)
        {
            throw new NotImplementedException();
        }

        public bool WriteArrayElement(string variable, int index, object value, out string reason)
        {
            throw new NotImplementedException();
        }

        public bool ReadBool(string address, out bool[] data, int length, out string reason)
        {
            try
            {
                double interval = _timerRead.GetElapseTime();
                if (interval > _averageWriteTime)
                {
                    //LOG.Write(_ip + "：Max read PLC interval : " + interval);
                    if (_averageReadTime < 0.1)
                        _averageReadTime = interval;
                    _averageReadTime = (interval + _averageReadTime) / 2;
                }
                
                _timerRead.Start(0);

                var read = omronFinsNet.ReadBool(address, (ushort)length);
                if (read.IsSuccess)
                {
                    data = (bool[])read.Content.Clone();
                }
                else
                {
                    data = null;
                    reason = read.Message;
                    return false;
                }

            }
            catch (Exception ex)
            {
                LOG.Error($"PLC ({_ip}) Read exception.", ex);

                reason = $"PLC ReadBool exception, {ex.Message}";

                data = null;

                return false;
            }

            reason = string.Empty;
            return true;
        }

        public bool ReadInt16(string address, out short[] data, int length, out string reason)
        {
            try
            {
                double interval = _timerRead.GetElapseTime();
                if (interval > _averageWriteTime)
                {
                    //LOG.Write(_ip + "：Max read PLC interval : " + interval);
                    if (_averageReadTime < 0.1)
                        _averageReadTime = interval;
                    _averageReadTime = (interval + _averageReadTime) / 2;
                }

                _timerRead.Start(0);

                var read = omronFinsNet.ReadInt16(address, (ushort)length);
                if (read.IsSuccess)
                {
                    data = (short[])read.Content.Clone();
                }
                else
                {
                    data = null;
                    reason = read.Message;
                    return false;
                }
            }
            catch (Exception ex)
            {
                LOG.Error($"PLC ({_ip}) ReadInt16 exception.", ex);

                reason = $"PLC ReadInt16 exception, {ex.Message}";

                data = null;

                return false;
            }

            reason = string.Empty;
            return true;
        }

        public bool ReadFloat(string address, out float[] data, int length, out string reason)
        {
            try
            {
                double interval = _timerRead.GetElapseTime();
                if (interval > _averageWriteTime)
                {
                    //LOG.Write(_ip + "：Max read PLC interval : " + interval);
                    if (_averageReadTime < 0.1)
                        _averageReadTime = interval;
                    _averageReadTime = (interval + _averageReadTime) / 2;
                }

                _timerRead.Start(0);

                var read = omronFinsNet.ReadFloat(address, (ushort)length);
                if (read.IsSuccess)
                {
                    data = (float[])read.Content.Clone();
                }
                else
                {
                    data = null;
                    reason = read.Message;
                    return false;
                }
            }
            catch (Exception ex)
            {
                LOG.Error($"PLC ({_ip}) ReadInt16 exception.", ex);

                reason = $"PLC ReadInt16 exception, {ex.Message}";

                data = null;

                return false;
            }

            reason = string.Empty;
            return true;
        }

        public bool WriteBool(string address, bool[] data, out string reason)
        {
            try
            {
                _timerWrite.Start(0);
                
                var write = omronFinsNet.Write(address, data);
                if (!write.IsSuccess)
                {
                    reason = write.Message;
                    return false;
                }

                double interval = _timerWrite.GetElapseTime();
                if (interval > _averageWriteTime)
                {
                    LOG.Write(_ip + "：Max write PLC interval : " + interval);
                    if (_averageWriteTime < 0.1)
                        _averageWriteTime = interval;
                    _averageWriteTime = (_averageWriteTime + interval) / 2;
                }
            }
            catch (Exception ex)
            {
                LOG.Error($"PLC ({_ip}) WriteBool exception.", ex);

                reason = $"PLC WriteBool exception, {ex.Message}";
                
                return false;
            }

            reason = string.Empty;
            return true;
        }

        public bool WriteInt16(string address, short[] data, out string reason)
        {
            try
            {
                _timerWrite.Start(0);

                var write = omronFinsNet.Write(address, data);
                if (!write.IsSuccess)
                {
                    reason = write.Message;
                    return false;
                }

                double interval = _timerWrite.GetElapseTime();



                if (interval > _averageWriteTime)
                {
                    LOG.Write(_ip + "：Max write PLC interval : " + interval);
                    if (_averageWriteTime < 0.1)
                        _averageWriteTime = interval;
                    _averageWriteTime = (_averageWriteTime + interval) / 2;
                }
            }
            catch (Exception ex)
            {
                LOG.Error($"PLC ({_ip}) WriteBool exception.", ex);

                reason = $"PLC WriteBool exception, {ex.Message}";

                return false;
            }

            reason = string.Empty;
            return true;
        }

        public bool WriteFloat(string address, float[] data, out string reason)
        {
            try
            {
                _timerWrite.Start(0);

                var write = omronFinsNet.Write(address, data);
                if (!write.IsSuccess)
                {
                    reason = write.Message;
                    return false;
                }

                double interval = _timerWrite.GetElapseTime();



                if (interval > _averageWriteTime)
                {
                    LOG.Write(_ip + "：Max write PLC interval : " + interval);
                    if (_averageWriteTime < 0.1)
                        _averageWriteTime = interval;
                    _averageWriteTime = (_averageWriteTime + interval) / 2;
                }
            }
            catch (Exception ex)
            {
                LOG.Error($"PLC ({_ip}) WriteBool exception.", ex);

                reason = $"PLC WriteBool exception, {ex.Message}";

                return false;
            }

            reason = string.Empty;
            return true;
        }
    }
}