Seyounth.Auto.Hs/share/Seyounth.Auto.Plc/Business/SycOmronFinsTcpNet.cs

using HslCommunication;
using HslCommunication.Profinet.Omron;
using Seyounth.Auto.Plc.Helper;
using Seyounth.Extensions.Plc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Seyounth.Auto.Plc.Business
{
    public class SycOmronFinsTcpNet : IPlc
    {
        public OmronFinsNet Melse;

        public string Host { get; }

        public int Port { get; }

        public bool IsConnected { get; }

        public int ConnectTimeOut = 1500;

        public SycOmronFinsTcpNet(string Ip, int Port)
        {
            this.Host = Ip;
            this.Port = Port;
        }

        public async Task ConnectAsync()
        {
            if (string.IsNullOrWhiteSpace(Host)) return;
            if (Host == default || Port == default) return;

            Melse = new OmronFinsNet(Host, Port);
            //Melse.SetPersistentConnection();
            Melse.ConnectTimeOut = ConnectTimeOut;
            await Melse.ConnectServerAsync();
        }

        public async Task DisconnectAsync()
        {
            await Melse.ConnectCloseAsync();
            Melse.Dispose();
        }

        public async Task<T[]> ReadAsync<T>(string address, int count)
        {
            T[] result = new T[count];
            var structName = typeof(T).ToString();
            var ReadByteLength = AnalysisHelper.TructToByteCount(structName: structName);
            var ReadRegLength = AnalysisHelper.TructToRegCount(structName: structName);
            var operateResult = await Melse.ReadAsync(address, (ushort)(count * ReadRegLength));

            if (!operateResult.IsSuccess)
            {
                throw new Exception(operateResult.Message);
            }
            for (int i = 0; i < count; i++)
            {
                T item = AnalysisHelper.ConvertBytes<T>(operateResult.Content, Melse, i * ReadByteLength);
                result[i] = item;
            }
            return result;
        }

        public async Task<string> ReadStringAsync(string address, int length)
        {
            var operateResult = await Melse.ReadAsync(address, (ushort)length);
            if (operateResult != null && operateResult.IsSuccess)
            {
                return Encoding.ASCII.GetString(operateResult.Content).Replace("\0", "").Trim();
            }
            return string.Empty;
        }

        public async Task<string> ReadStringAsync(string address, int length, Encoding encoding)
        {
            var operateResult = await Melse.ReadAsync(address, (ushort)length);
            if (operateResult != null && operateResult.IsSuccess)
            {
                return encoding.GetString(operateResult.Content).Replace("\0", "").Trim();
            }
            return string.Empty;
        }

        public Task WriteAsync<T>(string address, params T[] values)
        {
            throw new NotImplementedException();
        }

        public async Task WriteStringAsync(string address, string value)
        {
            byte[] bytes = Encoding.ASCII.GetBytes(value);
            await Melse.WriteAsync(address, bytes);
        }

        public async Task WriteStringAsync(string address, string value, Encoding encoding)
        {
            byte[] bytes = encoding.GetBytes(value);
            await Melse.WriteAsync(address, bytes);
        }
    }
}