用C# 根据 JSC100 V5.0读写器通讯协议 编写读卡器API

JSC100 V5.0读写器通讯协议
一、通讯格式
波特率：9600 8 1 N
数据包长度L(1byte) 命令字C(1byte) 数据包D(L-1bytes)
通讯方向：
-> 下位机(读卡器)送给上位机(PC)
<- 上位机(PC)送给下位机(读卡器)
二、单步读卡命令说明（以下数据全为16进制数据）
1) 启动（风鸣器响）
<- 02 0B 0F (02为长度,0B为命令字,测试凤鸣器,0F凤鸣器响的时间)
-> 01 00 (01为长度,00为测试成功)
2) 寻卡（返回卡的类型）
<- 02 02 26 (02为命令字,26为RegMfOutSelect)
-> 03 00 04 00 (00为命令成功代码,04表示Mifare One卡)
3) 防冲突（返回卡的系列号）
<- 01 03 (03为命令字)
-> 05 00 52 00 75 7A (52 00 75 7A为卡号CardSerialNo)
4) 选择
<- 01 04 (04为命令字)
-> 03 00 80 00
5) 终止（使卡休眠）
<- 01 01 (01为命令字)
-> 01 00
6) 密码下载(新卡的密码为6个字节的FF)
<- 09 06 60 01 FF FF FF FF FF FF (06为命令字,60为密码A(61为密码B),01为扇区号,12个F为密码)
-> 01 00
7) 数据读
<- 02 02 52 (02为命令字,52为PICC_REQALL)
-> 03 00 04 00 (04为RegFIFOLength)
<- 01 03 (03为命令字)
-> 05 00 52 00 75 7A (52 00 75 7A为卡号)
<- 01 04 (04为命令字)
-> 03 00 08 00
<- 04 05 60 01 04 (校验密码，05为命令字,60为密码A(61为密码B),01为扇区1,04为RegFIFOLength)
-> 01 00
<- 02 08 04 (08为命令字读命令,04为块号)
-> 11 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 (16个00为数据)
<- 02 08 05 (08为命令字,05为块号)
-> 11 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 (16个00为数据)
<- 02 08 06 (08为命令字,06为块号)
-> 11 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 (16个00为数据)
<- 02 08 07 (08为命令字,07为块号)
-> 11 00 00 00 00 00 00 00 ff 07 80 69 ff ff ff ff ff ff (第一个00为返回代码，后面6个00为密码A[不可现],ff 07 80 69为控制位，后面6个ff为密码B[可现])
8) 数据写
<- 12 09 04 12 30 00 00 00 00 00 00 00 00 00 00 00 00 00 00 (09为命令字写命令,04为块号,12开始的16个字节为要写的数据)
-> 01 00
<- 12 09 05 45 60 00 00 00 00 00 00 00 00 00 00 00 00 00 00 (09为命令字,05为块号,45开始的16个字节为要写的数据)
-> 01 00
<- 12 09 06 78 90 00 00 00 00 00 00 00 00 00 00 00 00 00 00 (09为命令字,06为块号,78开始的16个字节为要写的数据)
-> 01 00
<- 12 09 07 11 11 11 11 11 11 ff 07 80 69 11 11 11 11 11 11 (09为命令字,07为块号,把密码A和密码B都修改成1)[可看成改密码的命令]
-> 01 00
9) 块值操作(初始化)
<- 12 09 04 11 11 11 11 EE EE EE EE 11 11 11 11 04 FB 04 FB (09为命令字块值初始化,04为块号,11开始的16个字节为要写的数据)
-> 01 00
10) 块值操作(读出)
<- 02 08 04 (08为命令字块值读出,04为块号)
-> 11 00 11 11 11 11 EE EE EE EE 11 11 11 11 04 FB 04 FB (11后面的16个自己是读出来的数据)
11) 块值操作(加值)
<- 08 0A C1 04 22 22 22 22 04 (0A为命令字块值加值,C1为PICC_INCREMENT,04为块号,4个字节的22是要加值的数据,04为块号)
-> 01 00
12) 块值操作(减值)
<- 08 0A C0 04 11 11 11 11 04 (0A为命令字,C1为PICC_DECREMENT为块号,4个字节的11是要减值的数据,04为块号)
-> 01 00
13) 修改密码
<- 02 02 26 (02为命令字,26为RegMfOutSelect)
-> 03 00 04 00
<- 01 03 (03为命令字)

-> 05 00 52 00 75 7A (52 00 75 7A为卡号)
<- 01 04 (04为命令字)
-> 03 00 80 00
<- 04 05 60 01 04 (05为命令字,60为密码A(61为密码B),01为扇区号，04为RegFIFOLength)
-> 01 00
<- 12 09 07 33 33 33 33 33 33 ff 07 80 69 33 33 33 33 33 33 (09为命令字,07为块号,33后面的12个字节为新密码)
-> 01 00
14) 自动寻卡
<- 02 0E 26 (0E为命令字,26为RegMfOutSelect)
-> 03 00 04 00 (00为命令成功代码,04表示Mifare One卡)
15) 进入软件掉电模式(内部电流消耗模块包括晶振在内关闭)
<- 01 10 (0C为命令字)
-> 01 00
16) 退出软件掉电模式
<- 01 11 (0C为命令字)
-> 01 00

代码

using System;
using System.Collections.Generic;
using System.Text;
using System.IO.Ports;

namespace Card.Utility
{
/// <summary>
/// 摘要：读写卡操作基础类
/// </summary>
public class CardManagerUtil
{

private static SerialPort _serialPort;

#region CardManagerUtil 成员

/// <summary>
/// 初始化
/// </summary>
/// <param name="port">端口号</param>
/// <param name="baud">波特率</param>
/// <returns></returns>
public static int rf_init(int port, long baud)
{
string portName = GetPortName(port);
if (_serialPort != null)
{
if (_serialPort.IsOpen)
_serialPort.Close();
}
_serialPort = new SerialPort(portName, Convert.ToInt32(baud));
_serialPort.Parity = Parity.None;
_serialPort.StopBits = StopBits.One;
_serialPort.DataBits = 8;
_serialPort.WriteTimeout = 1;

try
{
if (_serialPort.IsOpen)
_serialPort.Close();
_serialPort.Open();
return 100;
}
catch
{
return -1;
}
}

/// <summary>
/// 重置读卡器
/// </summary>
/// <param name="icdev">设备号</param>
/// <param name="_Msec"></param>
/// <returns></returns>
public static int rf_reset(int icdev, int _Msec)
{
try
{
if (icdev != 100)
return 1;
if (_serialPort.IsOpen)
_serialPort.Close();
_serialPort.Open();
return 0;
}
catch
{
return -1;
}
}

/// <summary>
/// 成功返回0
/// </summary>
/// <param name="icdev"></param>
/// <param name="_Msec"></param>
/// <returns>成功返回0否则返回1</returns>
public static int rf_beep(int icdev, int _Msec)
{
if (icdev != 100)
return 1;
byte[] beepData = { 0x02, 0x0B, 0x0F };
byte[] buffer;
int bufLength = WriteAndRead(beepData, 0, beepData.Length, 2, out buffer);
if (bufLength == 0)
return 1;
if (buffer.Length == 2)
{
if (buffer[1] == 0x00)
return 0;
}
return 1;
}

/// <summary>
/// 返回卡号
/// </summary>
/// <param name="icdev"></param>
/// <param name="_Mode"></param>
/// <param name="_Snr"></param>
/// <returns></returns>
public static int rf_card(int icdev, byte _Mode, out uint _Snr)
{
int cardType = 0;
_Snr = 0;
if (rf_request(icdev, 0, out cardType) != 0)
return 1;
rf_anticoll(icdev, 0, out _Snr);
return 1;
}

/// <summary>
/// 终止卡（卡休眠）
/// </summary>
/// <param name="icdev"></param>
/// <returns></returns>
public static int rf_halt(int icdev)
{
if (icdev != 100)
return 1;
byte[] haltData = { 0x01, 0x01 };

byte[] buffer;
int bufLength = WriteAndRead(haltData, 0, haltData.Length, 2, out buffer);

if (bufLength == 0)
return 1;
if (buffer.Length == 2)
{
if (buffer[1] == 0x00)
return 0;
}
return 1;
}

/// <summary>
/// 寻卡
/// </summary>
/// <param name="icdev"></param>
/// <param name="_Mode"></param>
/// <param name="TagType"></param>
/// <returns></returns>
public static int rf_request(int icdev, byte _Mode, out int TagType)
{

TagType = 0;
if (icdev != 100)
return 1;
byte[] requestData = { 0x02, 0x02, 0x52 };

byte[] buffer = new byte[4];
int bufLength = WriteAndRead(requestData, 0, requestData.Length, 4, out buffer);

if (bufLength == 0)
return 1;
if (buffer.Length == 4)
{
TagType = (int)buffer[2];
if (buffer[1] == 0x00)
return 0;
}
return 1;
}

/// <summary>
/// 卡防冲突
/// </summary>
/// <param name="icdev"></param>
/// <param name="_Bcnt">0</param>
/// <param name="_Snr"></param>
/// <returns></returns>
public static int rf_anticoll(int icdev, byte _Bcnt, out uint _Snr)
{
_Snr = 0;
if (icdev != 100)
return 1;
byte[] anticollData = { 0x01, 0x03 };

byte[] buffer;
int bufLength = WriteAndRead(anticollData, 0, anticollData.Length, 6, out buffer);

if (bufLength == 0)
return 1;
if (buffer.Length == 6)
{
if (buffer[1] == 0x00)
{
List<byte> tempSnr = new List<byte>();
for (int i = 5; i > 1; i--)//低位在前高位在后
{
tempSnr.Add(buffer[i]);
}
if (tempSnr.Count == 4)
_Snr = BitConverter.ToUInt32(tempSnr.ToArray(), 0);
return 0;
}
}
return 1;
}

/// <summary>
/// 选择卡
/// </summary>
/// <param name="icdev"></param>
/// <param name="_Snr"></param>
/// <param name="_Size"></param>
/// <returns></returns>
public static int rf_select(int icdev, uint _Snr, out byte _Size)
{
_Size = 8;
if (icdev != 100)
return 1;
byte[] selectData = { 0x01, 0x04 };

byte[] buffer;
int bufLength = WriteAndRead(selectData, 0, selectData.Length, 4, out buffer);

if (bufLength == 0)
return 1;
if (buffer.Length == 4)
{
if (buffer[1] == 0x00)
return 0;
}
return 1;
}

/// <summary>
/// 加载密码
/// </summary>
/// <param name="icdev">设备号</param>
/// <param name="_Mode">60为密码A(61为密码B)</param>
/// <param name="_SecNr">扇区号</param>
/// <param name="key">密码</param>
/// <returns></returns>
public static int rf_load_key(int icdev, byte _Mode, byte _SecNr, byte[] key)
{
if (icdev != 100)
return 1;
byte[] keycmd = { 0x09, 0x06, _Mode, _SecNr };

List<byte> keyData = new List<byte>();

if (key.Length != 6)//6字节的密码
{
return 1;
}
else
{
keyData.AddRange(keycmd);
keyData.AddRange(key);
}

byte[] buffer;
int bufLength = WriteAndRead(keyData.ToArray(), 0, keyData.Count, 2, out buffer);

if (bufLength == 0)
return 1;
if (buffer.Length == 2)
{
if (buffer[1] == 0x00)
return 0;
}
return 1;
}

/// <summary>
/// 验证密码
/// </summary>
/// <param name="icdev"></param>
/// <param name="_Mode">密码组60为A组,61为B组</param>
/// <param name="_SecNr"></param>
/// <returns></returns>
public static int rf_authentication(int icdev, byte _Mode, byte _SecNr)
{
byte RegFIFOLength = (byte)(((int)_SecNr) * 4);
if (icdev != 100)
return 1;

byte[] authData = { 0x04, 0x05, _Mode, _SecNr, RegFIFOLength };

byte[] buffer;
int bufLength = WriteAndRead(authData, 0, authData.Length, 2, out buffer);

if (bufLength == 0)
return 1;
if (buffer.Length == 2)
{
if (buffer[1] == 0x00)
return 0;
}
return 1;

}

/// <summary>
/// 从某个扇区读取数据
/// </summary>
/// <param name="icdev">设备号</param>
/// <param name="_Adr">块号</param>
/// <param name="_Data">读取到的数据</param>
/// <returns></returns>
public static int rf_read(int icdev, byte _Adr, ref byte[] _Data)
{
if (icdev != 100)
return 1;
byte[] readCmdData = { 0x02, 0x08, _Adr };

byte[] buffer;
int bufLength = WriteAndRead(readCmdData, 0, readCmdData.Length, 18, out buffer);

if (bufLength == 0)
return 1;
if (buffer.Length == 18)
{
if (buffer[1] == 0x00)
{
List<byte> tempData = new List<byte>();
for (int i = 2; i < 18; i++)
{
tempData.Add(buffer[i]);
}
_Data = tempData.ToArray();
return 0;
}
}
return 1;
}

/// <summary>
/// 向某个扇区写入数据
/// </summary>
/// <param name="icdev"></param>
/// <param name="_Adr">块号</param>
/// <param name="_Data">要写的数据</param>
/// <returns></returns>
public static int rf_write(int icdev, byte _Adr, byte[] _Data)
{
if (icdev != 100)
return 1;
byte[] writeCmdData = { 0x12, 0x09, _Adr };
List<byte> cmdData = new List<byte>();
if (_Data.Length != 16)//16字节的数据
{
return 1;
}
else
{
cmdData.AddRange(writeCmdData);
cmdData.AddRange(_Data);
}

byte[] buffer;
int bufLength = WriteAndRead(cmdData.ToArray(), 0, cmdData.Count, 2, out buffer);
if (bufLength == 0)
return 1;
if (buffer.Length == 2)
{
if (buffer[1] == 0x00)
{
return 0;
}
}
return 1;
}

/// <summary>
/// 关闭串口
/// </summary>
/// <param name="icdev"></param>
/// <returns></returns>
public static int rf_exit(int icdev)
{
if (_serialPort != null)
{
if (_serialPort.IsOpen)
_serialPort.Close();
return 0;
}
return 1;
}

#endregion

#region 私有方法

/// <summary>
/// 向串口写数据并阻塞等待数据返回
/// </summary>
/// <param name="buffer"></param>
/// <param name="offset"></param>
/// <param name="count"></param>
/// <param name="ReadRoom"></param>
/// <param name="readBuf"></param>
/// <param name="ByteTime"></param>
/// <returns></returns>
static int WriteAndRead(byte[] buffer, int offset, int count, int ReadRoom, out byte[] readBuf)
{
_serialPort.Write(buffer, offset, count);
int val = ReadBlock(ReadRoom, out readBuf, 500);
return val;
}

static string GetPortName(int port)
{
string portName = string.Empty;
switch (port)
{
case 0:
portName = "COM1";
break;
case 1:
portName = "COM2";
break;
case 2:
portName = "COM3";
break;
case 3:
portName = "COM4";
break;
case 4:
portName = "COM5";
break;
default:
portName = "COM1";
break;
}
return portName;
}

/// <summary>
/// 串口同步读(阻塞方式读串口，直到串口缓冲区中没有数据,靠字符间间隔超时确定没有数据)
/// </summary>
/// <param name="ReadRoom">串口数据缓冲空间大小</param>
/// <param name="ByteTime">字节间隔最大时间</param>
/// <returns>从串口实际读入的字节</returns>
private static int ReadBlock(int ReadRoom, out byte[] readBuf, int ByteTime)
{
readBuf = new Byte[ReadRoom];
Array.Clear(readBuf, 0, readBuf.Length);
sbyte nBytelen;
if (_serialPort.IsOpen == false)
return 0;
nBytelen = 0;
_serialPort.ReadTimeout = ByteTime;
while (nBytelen < ReadRoom)
{
try
{
readBuf[nBytelen] = (byte)_serialPort.ReadByte();
nBytelen++;
}
catch
{
return 0;
}
}
return nBytelen;
}
#endregion

}
}