HighWayAssemble2.0/SlnMesnac.Rfid/Factory/FuchsFactory.cs

using SlnMesnac.Common;
using SlnMesnac.Model.domain;
using SlnMesnac.Model.dto;
using SlnMesnac.Rfid.Dto;
using SlnMesnac.Serilog;
using SlnMesnac.TouchSocket;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TouchSocket.Core;
using TouchSocket.Sockets;

namespace SlnMesnac.Rfid.Factory
{
    public class FuchsFactory : RfidAbsractFactory
    {
        private SerilogHelper _logger;
        private readonly TcpClient _tcpClient = new TcpClient();
        private readonly StringChange _stringChange;
        private string m_strIP;
        private string m_deviceID;
        private MeshttpClient _meshttpClient;

        public FuchsFactory(SerilogHelper logger, StringChange stringChange, MeshttpClient meshttpClient)
        {
            _logger = logger;
            _stringChange = stringChange;
            _meshttpClient = meshttpClient;
        }
        public override void Close()
        {
            _tcpClient.CloseAsync();
        }

        public override bool Connect(string ip, int port)
        {
            try
            {
                _tcpClient.SetupAsync(new TouchSocketConfig().SetRemoteIPHost($"{ip}:{port}"));
                _tcpClient.ConnectAsync();
                return true;
            }
            catch (Exception e)
            {
                return false;
                //throw new InvalidOperationException($"设备连接异常：{e.Message}");
            }
        }

        public override async Task<bool> ConnectAsync(string ip, int port, string deviceid)
        {
            try
            {
                m_deviceID = deviceid;
                m_strIP = ip;
                _tcpClient.SetupAsync(new TouchSocketConfig().SetRemoteIPHost($"{ip}:{port}"));
                await _tcpClient.ConnectAsync(1500);
                _tcpClient.Received = (client, e) =>
                {
                    //从客户端收到信息
                    var mes = Encoding.UTF8.GetString(e.Memory.Span.ToArray(), 0, e.Memory.Span.Length);//注意：数据长度是byteBlock.Len

                    byte[] receivedBuffer = new byte[e.Memory.Span.Length];
                    Array.Copy(e.Memory.Span.ToArray(), 0, receivedBuffer, 0, e.Memory.Span.Length);
                   
                    return EasyTask.CompletedTask;
                };
                return true;
            }
            catch (Exception e)
            {
                return false;
            }
        }

        public override bool GetOnlineStatus()
        {
            try
            {
                return _tcpClient.Online;
            }
            catch (Exception e)
            {
                return false;
            }
        }

        public override Task<List<TagInfo>> GetRFIDAsync(int timeout = 1500)
        {
            throw new NotImplementedException();
        }

        public override Task<int> Get_Rf()
        {
            throw new NotImplementedException();
        }

        public override Task<bool> Set_Rf(int iDbi)
        {
            throw new NotImplementedException();
        }

        public override Task<bool> WriteAlarmLight(int port, ushort Timedout)
        {
            throw new NotImplementedException();
        }

        public override async Task<bool> Set_FilterData(string Filter)
        {
            bool iflag = false;
            Filter = "FC 08";
            try
            {
                if (!string.IsNullOrEmpty(Filter))
                {
                    var waitClient = _tcpClient.CreateWaitingClient(new WaitingOptions()
                    {
                        FilterFunc = response =>
                        {
                            // 检查响应数据是否符合预期
                            if ( response.Memory.Length > 0)
                            {
                                // 可以根据实际情况添加更多的检查逻辑
                                return true;
                            }
                            return false;
                        }
                    });
                    //_logger.Info($"{m_deviceID}发送修改功率指令{_stringChange.bytesToHexStr(pMessagePack.m_pData, pMessagePack.m_pData.Length)}");
                    Filter = "filter "+ Filter.Replace(" ", "").Length / 2+ " " + Filter + "\r\n";
                    //byte[] reciveBuffer = await waitClient.SendThenReturnAsync(Filter + "\r\n", 2000);
                    using (var responsedData = await waitClient.SendThenResponseAsync(Filter, 2000))
                    {
                        var memory = responsedData.Memory;
                        string result = Encoding.GetEncoding("GBK").GetString(memory.ToArray(), 0, memory.Length);
                        _logger.Info($"{m_deviceID}接收设置过滤指令{result}");
                        return true;
                    }
                    //_logger.Info($"{m_deviceID}接收修改功率指令{_stringChange.bytesToHexStr(reciveBuffer, reciveBuffer.Length)}");
                }
                return iflag;
            }
            catch (Exception ex)
            {

                return iflag;
            }
        }

        public override async Task<string> Get_FilterData()
        {
            string iflag = "";
            try
            {
                var waitClient = _tcpClient.CreateWaitingClient(new WaitingOptions()
                {
                    FilterFunc = response =>
                    {
                        // 检查响应数据是否符合预期
                        if ( response.Memory.Length > 0)
                        {
                            // 可以根据实际情况添加更多的检查逻辑
                            return true;
                        }
                        return false;
                    }
                });
                //_logger.Info($"{m_deviceID}发送修改功率指令{_stringChange.bytesToHexStr(pMessagePack.m_pData, pMessagePack.m_pData.Length)}");

                //byte[] reciveBuffer = await waitClient.SendThenReturnAsync("filter?\r\n", 2000);

                using (var responsedData = await waitClient.SendThenResponseAsync("filter?\r\n",2000))
                {
                    var memory = responsedData.Memory;
                    string result = Encoding.GetEncoding("GBK").GetString(memory.ToArray(), 0, memory.Length);
                    _logger.Info($"{m_deviceID}接收设置过滤指令{result}");
                    return result;
                }
                return iflag;
            }
            catch (Exception ex)
            {

                return iflag;
            }
        }
    }
}