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

时间：2014-05-21 20:38:45 收藏：0 阅读：474

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

不解释上代码：

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

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通讯类。不然没法通许不是

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

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简单明了想要搞个程序还是很容易的。

C# RFID windows 服务网络协议方式,布布扣,bubuko.com

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

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