C# RFID windows 服务 网络协议方式

上篇话说是串口方式操作RFID设备。 下面介绍网络协议方式。 设备支持断线重连。 那我们的服务也不能差了不是。 所以这个服务类也是支持的哦。 

不解释上代码：

namespace Rfid
{
    /// <summary>
    /// 获取Vip数据
    /// </summary>
    /// <param name="vip"></param>
    public delegate void GetVipEventHandle(object obj, MarkArgs vip);

    /// <summary>
    /// 识别标签
    /// </summary>
    /// <param name="idMark"></param>
    public delegate void IdentificationMarksEventHandle(object obj, MarkArgs idMark);

    /// <summary>
    /// 写标签
    /// </summary>
    public delegate void WriteMarksEventHandle(object obj, MarkArgs writeMark);



    public class RfidSocket
    {
        public event GetVipEventHandle GetVip;

        public event IdentificationMarksEventHandle IdentificationMarks;

        public event WriteMarksEventHandle WriteMarks;

        /// <summary>
        /// 识别标签协议
        /// </summary>
        public readonly byte[] MReadMarks = new byte[5] { 0xA0, 0x03, 0x82, 0x00, 0xDB };

        /// <summary>
        /// 接受失败协议
        /// </summary>
        public readonly byte[] MErrorHeader = new byte[3] { 0xE4, 0x04, 0x82 };

        /// <summary>
        /// 接受成功协议
        /// </summary>
        public readonly byte[] MSucessHeader = new byte[3] { 0xE0, 0x10, 0x82 };

        /// <summary>
        /// Vip数据长度
        /// </summary>
        public const int MDataLength = 12;

        /// <summary>
        /// 发送读取协议证
        /// </summary>
        public System.Windows.Forms.Timer MTimer = new System.Windows.Forms.Timer();

        /// <summary>
        /// 链接状态
        /// </summary>
        public bool Connected = false;

        /// <summary>
        /// Vip编号
        /// </summary>
        public string VipId = string.Empty;

        /// <summary>
        /// 全局锁
        /// </summary>
        public object MLock = new object();

        /// <summary>
        /// Socket通讯
        /// </summary>
        public SocketClient Client = new SocketClient();

        /// <summary>
        /// 连接错误次数
        /// </summary>
        public int MConnectErrorCount = 0;

        public string Ip { get; set; }
        public int Port { get; set; }
        public int ErrorCount { get; set; }
        public RfidSocket(string ip, int port, int errorCount)
        {
            this.Ip = ip;
            this.Port = port;
            this.ErrorCount = errorCount;

        }

        void client_OnDisconnected(object sender)
        {
            Client.mOnConnected -= client_mOnConnected;
            Client.mOnError -= client_mOnError;
            Client.OnDataIn -= client_OnDataIn;
            Client.OnDisconnected -= client_OnDisconnected;
        }

        void client_OnDataIn(object sender, byte[] data)
        {
            try
            {
                GC.Collect();
                GC.WaitForFullGCComplete();
                GC.Collect();

                //当前不考虑数据协议失败情况
                Monitor.Enter(MLock);

                //判断消息头
                if (data.Length > 3)
                {
                    IdentificationTag(data);

                    WriteTag(data);
                }

                ReaderTag(data);
            }
            finally
            {
                Monitor.Exit(MLock);
            }
        }

        /// 识别标签协
        private void IdentificationTag(byte[] data)
        {
            //识别标签协议成功
            if (data[0] == 0xE0 && data[1] == 0x10 && data[2] == 0x82)
            {
                //解析标签成功
                if (data.Length >= 18)
                {
                    var vipByte = new byte[4];
                    Array.Copy(data, 13, vipByte, 0, vipByte.Length);
                    var vipId = ((vipByte[0]) + (vipByte[1] << 8) + (vipByte[2] << 16) + (vipByte[3] << 32)).ToString();
                    if (IdentificationMarks != null)
                    {
                        var markArgs = new MarkArgs(vipId, string.Empty, true);
                        IdentificationMarks(this, markArgs);
                    }
                }
            }
            else if (data[0] == 0xE4 && data[1] == 0x04 && data[2] == 0x82)
            {
                if (IdentificationMarks != null)
                {
                    var markArgs = new MarkArgs(string.Empty, string.Empty, false);
                    IdentificationMarks(this, markArgs);
                }
            }
        }

        /// 快写标签
        private void WriteTag(byte[] data)
        {
            if (data[0] == 0xE0 && data[1] == 0x04 && data[2] == 0x9C)
            {
                if (data.Length >= 6)
                {
                    if (data[4] == 0x0)
                    {
                        //写标签成功
                        if (WriteMarks != null)
                        {
                            var markArgs = new MarkArgs(string.Empty, string.Empty, true);
                            WriteMarks(this, markArgs);
                        }
                    }
                    else
                    {
                        //写标签失败
                        if (WriteMarks != null)
                        {
                            var markArgs = new MarkArgs(string.Empty, string.Empty, false);
                            WriteMarks(this, markArgs);
                        }
                    }
                }
            }
        }

        /// 定时模式读取标签
        private void ReaderTag(byte[] data)
        {
            if (data.Length >= 17)
            {
                if (data[0] == 0x00 && data[1] == 0x00 && data[16] == 0xFF)
                {
                    var bytCheck = new byte[15];
                    Array.Copy(data, 0, bytCheck, 0, 15);
                    var checkSum = EPCSDKHelper.CheckSum(bytCheck) & 0xFF;//校验和
                    if (data[15] == checkSum)
                    {
                        var vipByte = new byte[4];
                        Array.Copy(bytCheck, 10, vipByte, 0, 4);
                        var vipId = ((vipByte[0]) + (vipByte[1] << 8) + (vipByte[2] << 16) + (vipByte[3] << 32)).ToString();
                        this.VipId = vipId;
                        if (GetVip != null)
                        {
                            var markArgs = new MarkArgs(this.VipId, string.Empty, true);
                            GetVip(this, markArgs);
                        }
                    }
                }
            }
        }

        private void client_mOnError(object sender, SocketException error)
        {
            if (!Client.ConnectFlag)
            {
                ReConnect();
            }
        }

        private void client_mOnConnected(object sender)
        {
            MConnectErrorCount = 0;
        }

        private void ReConnect()
        {
            if (Client != null)
            {
                Client.mOnConnected -= client_mOnConnected;
                Client.mOnError -= client_mOnError;
                Client.OnDataIn -= client_OnDataIn;
                Client.OnDisconnected -= client_OnDisconnected;
            }
            Client = new SocketClient();
            Client.Connect(this.Ip, this.Port);
            Client.mOnConnected += client_mOnConnected;
            Client.mOnError += client_mOnError;
            Client.OnDataIn += client_OnDataIn;
            Client.OnDisconnected += client_OnDisconnected;
        }

        private void mTimer_Tick(object sender, EventArgs e)
        {
            try
            {
                MTimer.Enabled = false;
                if (Client.ConnectFlag)
                {
                    Client.Send(TagProtocol.MIdentificationMarks);
                }
                else
                {
                    MConnectErrorCount++;
                    if (MConnectErrorCount > this.ErrorCount)
                    {
                        ReConnect();
                    }
                }
            }
            finally
            {
                MTimer.Enabled = true;
            }
        }

        public void Start()
        {
            Client = new SocketClient();
            Client.Connect(this.Ip, this.Port);
            Client.mOnConnected += client_mOnConnected;
            Client.mOnError += client_mOnError;
            Client.OnDataIn += client_OnDataIn;
            Client.OnDisconnected += client_OnDisconnected;

            MTimer.Interval = 1000;
            MTimer.Enabled = true;
            MTimer.Tick += mTimer_Tick;
        }

        public void ClearVipId()
        {
            try
            {
                Monitor.Enter(MLock);
                this.VipId = string.Empty;
            }
            finally
            {
                Monitor.Exit(MLock);
            }
        }

        public void WriteMark(int mark)
        {
            if (mark < 0 && mark > 0xffffffff)
            {
                throw new Exception("超出写标签范围！");
            }
            var markByte = mark.ToString("x").PadLeft(8, '0');
            var byt = new byte[4];
            for (var i = 0; i < markByte.Length; i = i + 2)
            {
                byt[i / 2] = (byte)Convert.ToInt32(markByte[i].ToString() + markByte[i + 1].ToString(), 16);
            }
            var writeMarkData = new byte[10];
            Array.Copy(TagProtocol.MWriteMark, 0, writeMarkData, 0, TagProtocol.MWriteMark.Length);
            Array.Copy(byt, 0, writeMarkData, TagProtocol.MWriteMark.Length, byt.Length);
            //写校验和
            writeMarkData[9] = (byte)(EPCSDKHelper.CheckSum(writeMarkData) & 0xFF);
            Client.Send(writeMarkData);

            GC.Collect();
            GC.WaitForFullGCComplete();
            GC.Collect();
        }
    }

　　上面介绍了网络通讯的设备类当然也少不了Socket通讯类。 不然没法通许不是

namespace Rfid
{
    public delegate void ClientErrorEvent(object sender, SocketException error);
    public delegate void ClientOnDataInHandler(object sender, byte[] data);
    public delegate void ClientEvent(object sender);

    public class SocketClient
    {
        public event ClientEvent mOnConnected = null;
        public event ClientEvent OnDisconnected = null;
        public event ClientOnDataInHandler OnDataIn = null;
        public event ClientErrorEvent mOnError = null;
        private Socket cli = null;
        private byte[] databuffer;
        private int buffersize = 64 * 1024;

        public bool ConnectFlag
        {
            get
            {
                if (cli == null)
                {
                    return false;
                }

                return cli.Connected;
            }
        }
        private void RaiseDisconnectedEvent()
        {
            if (null != OnDisconnected) OnDisconnected(this);
        }
        private void RaiseErrorEvent(SocketException error)
        {
            if (null != mOnError) mOnError(this, error);
        }
        private void HandleConnectionData(IAsyncResult parameter)
        {
            Socket remote = (Socket)parameter.AsyncState;

            int read = remote.EndReceive(parameter);
            if (0 == read)
            {
                RaiseDisconnectedEvent();
            }
            else
            {
                byte[] received = new byte[read];
                Array.Copy(databuffer, 0, received, 0, read);
                if (null != OnDataIn) OnDataIn(this, received);
                StartWaitingForData(remote);
            }
        }
        private void HandleIncomingData(IAsyncResult parameter)
        {
            try
            {
                HandleConnectionData(parameter);
            }
            catch (ObjectDisposedException)
            {
                RaiseDisconnectedEvent();
            }
            catch (SocketException x)
            {
                if (x.ErrorCode == 10054)
                {
                    RaiseDisconnectedEvent();
                }
                RaiseErrorEvent(x);
            }
        }
        private void StartWaitingForData(Socket soc)
        {
            soc.BeginReceive(databuffer,
                0,
                buffersize,
                SocketFlags.None,
                new AsyncCallback(HandleIncomingData),
                soc);
        }

        private void HandleSendFinished(IAsyncResult parameter)
        {
            Socket socket = (Socket)parameter.AsyncState;
            socket.EndSend(parameter);
        }
        public SocketClient()
        {
            databuffer = new byte[buffersize];
        }
        private void Connected(IAsyncResult iar)
        {
            Socket socket = (Socket)iar.AsyncState;
            try
            {
                socket.EndConnect(iar);
            }
            catch (SocketException x)
            {
                RaiseErrorEvent(x);
                return;
            }
            catch (ArgumentException)
            {
                return;
            }
            catch (Exception e)
            {
                LogInfo.Error("Connected:" + e.Message);
                LogInfo.Error(e.StackTrace);
                return;
            }
            if (null != mOnConnected) mOnConnected(this);
            StartWaitingForData(socket);
        }
        public void Connect(string ip, int port)
        {
            cli = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint iep = new IPEndPoint(IPAddress.Parse(ip), port);
            try
            {
                cli.BeginConnect(iep, new AsyncCallback(Connected), cli);
            }
            catch (SocketException er)
            {
                LogInfo.Error("与服务器无法建立连接！错误编号：" + er.ErrorCode + " 错误消息：" + er.Message);
            }
        }
        public void Close()
        {
            cli.Shutdown(SocketShutdown.Both);
            cli.Close();
        }

        public void Send(byte[] buffer)
        {
            try
            {
                cli.BeginSend(buffer,
                    0,
                    buffer.Length,
                    SocketFlags.None,
                    new AsyncCallback(HandleSendFinished),
                    cli);
            }
            catch (ObjectDisposedException)
            {
                RaiseDisconnectedEvent();
            }
            catch (SocketException x)
            {
                RaiseErrorEvent(x);
            }
        }
    }

　　看到这些你有没有什么想说的。 提出你的想法。其实搞和硬件通讯还是很有趣的。下篇我将介绍一下让我恶心的不能再恶心的东进的电话卡模块。他的SDK简直无法用言语表达了（我只能说祝福了）。 对于RFID的SDK简单明了想要搞个程序还是很容易的。