CyberX8/Framework/Common/Device/Wago/WagoModbusDevice.cs

using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using DocumentFormat.OpenXml.Wordprocessing;
using MECF.Framework.Common.Device.PowerSupplier;
using MECF.Framework.Common.Net;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace MECF.Framework.Common.Device.Wago
{
    public class WagoModbusDevice : JetMessageTcpClient<WagoMessage, WagoCommand>
    {
        #region 常量 
        private const int DO_READ_CMD = 1;
        private const int DI_READ_CMD = 2;
        private const int AO_READ_CMD = 3;
        private const int AI_READ_CMD = 4;
        private const int DO_WRITE_CMD= 5;
        private const int AO_WRITE_CMD = 6;
        #endregion

        #region 内部变量
        /// <summary>
        /// 名称
        /// </summary>
        private string _name;
        /// <summary>
        /// 上一次错误信息
        /// </summary>
        private string _lastErrorMsg = "";
        /// <summary>
        /// 通道
        /// </summary>
        private byte _channel = 1;
        /// <summary>
        /// IP地址
        /// </summary>
        private string _ip = "";
        /// <summary>
        /// 端口号
        /// </summary>
        private int _port = 502;
        /// <summary>
        /// 定时器
        /// </summary>
        private PeriodicJob _periodicJob;
        /// <summary>
        /// 共享锁
        /// </summary>
        private object _locker = new object();
        /// <summary>
        /// 共享锁时长
        /// </summary>
        private int _lockerTime = 2000;
        /// <summary>
        /// AI总数
        /// </summary>
        private ushort _aiCount = 0;
        /// <summary>
        /// AI起始地址
        /// </summary>
        private ushort _aiStartAddress = 0;
        /// <summary>
        /// AO总数
        /// </summary>
        private ushort _aoCount = 0;
        /// <summary>
        /// AO起始地址
        /// </summary>
        private ushort _aoStartAddress = 0;
        /// <summary>
        /// DI总数
        /// </summary>
        private ushort _diCount = 0;
        /// <summary>
        /// DI起始地址
        /// </summary>
        private ushort _diStartAddress = 0;
        /// <summary>
        /// DO总数
        /// </summary>
        private ushort _doCount = 0;
        /// <summary>
        /// DO起始地址
        /// </summary>
        private ushort _doStartAddress = 0;
        /// <summary>
        /// 读取索引
        /// </summary>
        private int _readIndex = 0;
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="ip"></param>
        /// <param name="port"></param>
        public WagoModbusDevice(string name, string ip, int port,byte channel) : base(ip, port)
        {
            ReceiveTimeout = 1000;
            SendTimeout = 1000;
            ConnectTimeout = 1000;
            _name = name;
            _ip = ip;
            _port = port;
            _channel = channel;
            _periodicJob = new PeriodicJob(50, OnTimer, $"Wago {name} timer", false,true);
        }
        /// <summary>
        /// 定时器执行
        /// </summary>
        /// <returns></returns>
        private bool OnTimer()
        {
            if(Monitor.TryEnter(_locker, _lockerTime))
            {
                if (_readIndex == 0)
                {
                    ApplyAllDIDatas();
                    _readIndex++;
                }
                else if(_readIndex==1)
                {
                    ApplyAllDODatas();
                    _readIndex++;
                }
                else if (_readIndex == 2)
                {
                    ApplyAllAIDatas();
                    _readIndex++;
                }
                else
                {
                    ApplyAllAODatas();
                    _readIndex = 0;
                }
                Monitor.Exit(_locker);
            }
            return true;
        }
        /// <summary>
        /// 更新地址数量
        /// </summary>
        public void Initialize(ushort diCount,ushort diStartAdress,ushort doCount,ushort doStartAdress,ushort aiCount,ushort aiStartAddress,
            ushort aoCount,ushort aoStartAddress)
        {
            _diCount = diCount;
            _diStartAddress = diStartAdress;
            _doCount = doCount;
            _doStartAddress=doStartAdress;
            _aiCount = aiCount;
            _aiStartAddress = aiStartAddress;
            _aoCount = aoCount;
            _aoStartAddress = aoStartAddress;
            NetResult result = Connect();
            if (result.IsSuccess)
            {
                LOG.WriteLog(eEvent.INFO_WAGO, _name, $"connect {_ip}:{_port} success");
            }
            else
            {
                LOG.WriteLog(eEvent.INFO_WAGO, _name, $"connect {_ip}:{_port} failed");
            }

            _periodicJob.Start();
        }
        /// <summary>
        /// 写入DO数值
        /// </summary>
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool WriteDOValue(ushort address, byte value)
        {
            WagoCommand command = new WagoCommand();
            command.Address = address;
            command.CommandCode = DO_WRITE_CMD;
            command.WriteValue = value;
            command.Channel = _channel;
            if (Monitor.TryEnter(_locker, _lockerTime))
            {
                bool result = SetOperation(command);
                Monitor.Exit(_locker);
                return result;
            }
            else
            {
                LOG.WriteLog(eEvent.ERR_WAGO, "Wago", $"Write apply locker over {_lockerTime}");
                return false;
            }
        }
        /// <summary>
        /// 写入AO数值
        /// </summary>
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool WriteAOValue(ushort address, byte[] value)
        {
            WagoCommand command = new WagoCommand();
            command.Address = address;
            command.CommandCode = AO_WRITE_CMD;
            command.WriteValue = value;
            command.Channel = _channel;
            if (Monitor.TryEnter(_locker, _lockerTime))
            {
                bool result = SetOperation(command);
                Monitor.Exit(_locker);
                return result;
            }
            else
            {
                LOG.WriteLog(eEvent.ERR_WAGO, "Wago", $"Write apply locker over {_lockerTime}");
                return false;
            }
        }

        /// <summary>
        /// 设置操作
        /// </summary>
        /// <param name="command"></param>
        /// <returns></returns>
        private bool SetOperation(WagoCommand command)
        {
            if (Connected)
            {
                return SetOperationCommand(command);
            }
            else
            {
                NetResult netResult = Connect();
                if (netResult.IsSuccess)
                {
                    return SetOperationCommand(command);
                }
                else
                {
                    WriteErrMsg("connect failed");
                    return false;
                }
            }
        }
        /// <summary>
        /// 设置操作指令
        /// </summary>
        /// <param name="command"></param>
        /// <returns></returns>
        private bool SetOperationCommand(WagoCommand command)
        {
            NetResult netResult = SetData(command);
            if (!netResult.IsSuccess)
            {
                WriteErrMsg($"write write {command.Address.ToString("X2")} value {command.WriteValue} failed,{netResult.Message}");
                return false;
            }
            return true;
        }
        #region 申请数据
        /// <summary>
        /// 申请所有DI数据
        /// </summary>
        public void ApplyAllDIDatas()
        {
            ApplyAllDataTypeDatas(DI_READ_CMD, _diCount, _diStartAddress);
        }
        /// <summary>
        /// 申请所有DO数据
        /// </summary>
        public void ApplyAllDODatas()
        {
            ApplyAllDataTypeDatas(DO_READ_CMD, _doCount, _doStartAddress);
        }
        /// <summary>
        /// 申请所有AI数据
        /// </summary>
        public void ApplyAllAIDatas()
        {
            ApplyAllDataTypeDatas(AI_READ_CMD, _aiCount, _aiStartAddress);
        }
        /// <summary>
        /// 申请所有AO数据
        /// </summary>
        public void ApplyAllAODatas()
        {
            ApplyAllDataTypeDatas(AO_READ_CMD, _aoCount, _aoStartAddress);
        }
        /// <summary>
        /// 申请所有数据类型数据
        /// </summary>
        /// <param name="dataType"></param>
        /// <param name="dataCount"></param>
        /// <param name="startAddress"></param>
        private void ApplyAllDataTypeDatas(byte dataType,ushort dataCount,ushort startAddress)
        {
            WagoCommand command = new WagoCommand();
            command.Address = startAddress;
            command.RegisterCount = dataCount;
            command.CommandCode = dataType;
            command.Channel = _channel;
            ApplyDataOperation(command);
        }
        /// <summary>
        /// 申请数据操作
        /// </summary>
        /// <param name="command"></param>
        private void ApplyDataOperation(WagoCommand command)
        {
            if (!Connected)
            {
                NetResult connectResult = Connect();
                if (!connectResult.IsSuccess)
                {
                    WriteErrMsg("connect failed");
                    return;
                }
            }
            NetResult<WagoCommand> netResult = ApplyData(command);
            if (!netResult.IsSuccess)
            {
                WriteErrMsg($"apply {command.Address.ToString("X2")} failed,{netResult.Message}");
                return;
            }
            if (netResult.Data.Datas != null)
            {
                if (command.CommandCode == DO_READ_CMD||command.CommandCode==DI_READ_CMD)
                {
                    bool[] digDatas = (bool[])netResult.Data.Datas;
                    bool[] digs = new bool[command.RegisterCount];
                    int count=command.RegisterCount>=digDatas.Length?digDatas.Length:command.RegisterCount;
                    Array.Copy(digDatas,0,digs,0,count);
                    if (command.CommandCode == DO_READ_CMD)
                    {
                        WagoControllerCfgManager.Instance.UpdateWagoDOData(_name, digs);
                    }
                    else
                    {
                        WagoControllerCfgManager.Instance.UpdateWagoDIData(_name, digs);
                    }
                }
                else
                {
                    byte[] datas = (byte[])netResult.Data.Datas;
                    if (command.CommandCode == AI_READ_CMD)
                    {
                        WagoControllerCfgManager.Instance.UpdateWagoAIData(_name, datas);
                        //LOG.WriteBackgroundLog(eEvent.INFO_WAGO, "Wago", string.Join(" ", Array.ConvertAll(datas,O=>O.ToString("X2"))));
                    }
                    else
                    {
                        WagoControllerCfgManager.Instance.UpdateWagoAOData(_name, datas);
                    }
                }
            }
        }
        #endregion
        /// <summary>
        /// 写错误日志
        /// </summary>
        /// <param name="msg"></param>
        private void WriteErrMsg(string msg)
        {
            if (msg != _lastErrorMsg)
            {
                _lastErrorMsg = msg;

                LOG.WriteLog(eEvent.ERR_WAGO, _name, msg);
            }
        }
    }
}