Shihong-Delta.Injection.Iot/Sln.Iot.PLC/PLCConnect.cs

using HslCommunication;
using HslCommunication.Profinet.Delta;
using Microsoft.Extensions.DependencyInjection;
using Serilog;
using Sln.Iot.Serilog;

namespace Sln.Iot.PLC
{
    public class PLCConnect
    {
        private SerilogHelper? LogHelper;

        public static DeltaSerialOverTcp DeltaInstance1;

        /// <summary>
        /// 锁对象1
        /// </summary>
        private static readonly object locker1 = new object();

        public PLCConnect(SerilogHelper serilogHelper)
        {
            LogHelper = serilogHelper;
            DeltaInstance1 = CreateDeltaConnect("127.0.0.1", 502, 1, serilogHelper);
        }

        /// <summary>
        /// 创建台达PLC连接
        /// </summary>
        /// <param name="ip"></param>
        /// <param name="port"></param>
        /// <param name="stationNo"></param>
        /// <param name="log"></param>
        /// <returns></returns>
        public static DeltaSerialOverTcp CreateDeltaConnect(string ip, int port, byte stationNo, SerilogHelper log)
        {
            DeltaSerialOverTcp plc = new DeltaSerialOverTcp(ip, port, stationNo);
            try
            {
                var res = plc.ConnectServer();
            }
            catch (Exception ex)
            {
                log.Error($"连接PLC[{ip}]失败", ex);
            }

            return plc;
        }

        /// <summary>
        /// PLC2写入数据
        /// </summary>
        /// <param name="address">地址</param>
        /// <param name="value">值</param>
        /// <param name="type">数据类型</param>
        /// <returns></returns>
        public static OperateResult PlcWrite(string address, object value, DataTypeEnum type)
        {
            var result = new OperateResult() { IsSuccess = false };

            lock (locker1)
            {
                switch (type)
                {
                    case DataTypeEnum.Bool:
                        result = DeltaInstance1.Write(address, Convert.ToBoolean(value));
                        break;
                    case DataTypeEnum.Byte:
                        result = DeltaInstance1.Write(address, Convert.ToByte(value));
                        break;
                    case DataTypeEnum.Int16:
                        result = DeltaInstance1.Write(address, Convert.ToInt16(value));
                        break;
                    case DataTypeEnum.UInt16:
                        result = DeltaInstance1.Write(address, Convert.ToUInt16(value));
                        break;
                    case DataTypeEnum.Int32:
                        result = DeltaInstance1.Write(address, Convert.ToInt32(value));
                        break;
                    case DataTypeEnum.UInt32:
                        result = DeltaInstance1.Write(address, Convert.ToUInt32(value));
                        break;
                    case DataTypeEnum.Int64:
                        result = DeltaInstance1.Write(address, Convert.ToInt64(value));
                        break;
                    case DataTypeEnum.UInt64:
                        result = DeltaInstance1.Write(address, Convert.ToUInt64(value));
                        break;
                    case DataTypeEnum.Float:
                        result = DeltaInstance1.Write(address, Convert.ToSingle(value));
                        break;
                    case DataTypeEnum.Double:
                        result = DeltaInstance1.Write(address, Convert.ToDouble(value));
                        break;
                    case DataTypeEnum.String:
                        result = DeltaInstance1.Write(address, Convert.ToString(value));
                        break;
                    default:
                        throw new ArgumentException($"Unsupported data type: {type}");
                }
            }
            return result;
        }

        /// <summary>
        /// 写入byte数组
        /// </summary>
        /// <param name="address"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public static OperateResult PlcWriteBytes(string address, byte[] data)
        {
            lock (locker1)
            {
                var res = DeltaInstance1.Write(address, data);
                return res;
            }
        }

        /// <summary>
        /// 读取int32
        /// </summary>
        /// <returns></returns>
        public OperateResult<int> ReadInt32(string address)
        {
            lock (locker1)
            {
                var res = DeltaInstance1.ReadInt32(address);
                return res;
            }
        }

        /// <summary>
        /// 读取int16
        /// </summary>
        /// <returns></returns>
        public OperateResult<short> ReadInt16(string address)
        {
            lock (locker1)
            {
                var res = DeltaInstance1.ReadInt16(address);
                return res;
            }
        }

        /// <summary>
        /// 读取float
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public OperateResult<float> ReadFloat(string address)
        {
            lock (locker1)
            {
                var res = DeltaInstance1.ReadFloat(address);
                return res;
            }
        }

        /// <summary>
        /// 读取Bool
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public OperateResult<bool> ReadBool(string address)
        {
            lock (locker1)
            {
                var res = DeltaInstance1.ReadBool(address);
                return res;
            }
        }

        /// <summary>
        /// 读取字节数组
        /// </summary>
        /// <param name="address"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public static OperateResult<byte[]> ReadByte2(string address, ushort length)
        {
            lock (locker1)
            {
                var res = DeltaInstance1.Read(address, length);
                return res;
            }
        }

        
    }
}