var PROTOCEL_FLAG = {
|
_reader_cmd_STX: 165, //命令头
|
_reader_cmd_ETX: 213, //命令尾
|
}
|
|
/**
|
* 读写器命令
|
*/
|
var READER_CMD = {
|
_reader_server_connect: 5, //读写器服务连接
|
_reader_server_close: 6, //读写器服务断开连接
|
_reader_cmd_connect: 10, //连接读写器
|
_reader_cmd_disconnect: 11, // 关闭读写器
|
_reader_cmd_read_ver: 12, // 读取硬件版本号
|
_reader_cmd_read_snr: 13, // 读取序列号
|
_reader_cmd_beep: 14, //读写器鸣响
|
_reader_cmd_set_baud: 15, //设置串口波特率
|
_reader_cmd_get_status: 16, //获取大卡座是否有卡
|
_reader_cmd_write_eeprom: 17, //写eeprom
|
_reader_cmd_read_eeprom: 18, //读eeprom
|
_reader_cmd_set_number: 19, //设置读写器编号
|
_reader_cmd_get_number: 20, //获取读写编号
|
_reader_cmd_turn_on: 21, //接触式卡座上电
|
_reader_cmd_turn_off: 22, //接触式卡座下电
|
_reader_cmd_rf_reset: 23, //射频头复位
|
_reader_cmd_select_protocol: 24, //选择协议
|
|
_reader_cmd_rf_card: 50, // 寻卡 TypeA
|
_reader_cmd_rf_halt: 51, // 停止卡 TypeA
|
_reader_cmd_rf_card_b: 52, // 寻卡 TypeB
|
_reader_cmd_rf_halt_b: 53, // 停止卡 TypeB
|
_reader_cmd_m_auth_key: 54, //S50/S70校验密码
|
_reader_cmd_m_write: 55, //s50/s70写数据
|
_reader_cmd_m_read: 56, //s50/s70读数据
|
_reader_cmd_m_init_value: 57, //s50/s70初始化值
|
_reader_cmd_m_read_value: 58, //s50/s70读值
|
_reader_cmd_m_increment_value: 59, //s50/s70加值
|
_reader_cmd_m_decrement_value: 60, //s50/s70减值
|
|
_reader_cmd_c_cpu_reset: 65, //非接cpu卡复位TypeA
|
_reader_cmd_c_cpu_reset_b: 66, //非接cpu卡复位TypeB
|
_reader_cmd_c_cpu_Transmit: 67, //非接cpu发送指令TypeA/B
|
|
_reader_cmd_uc_auth_key: 70, //ultralight C 校验密码
|
_reader_cmd_uev_auth_key: 71, //ultralight EV 校验密码
|
_reader_cmd_u_read: 72, //读ultralight/C数据
|
_reader_cmd_u_write: 73, //写ultralight/C数据
|
_reader_cmd_uc_change_key: 74, //更改ultralight C密码
|
|
_reader_cmd_ntag_auth_pwd: 80, //校验ntag密码
|
_reader_cmd_ntag_read: 81, //读ntag数据
|
_reader_cmd_ntag_write: 82, //写ntag数据
|
_reader_cmd_ntag_counter: 83, //读ntag中nfc单向计数器的值
|
_reader_cmd_ntag_version: 84, //读ntag版本信息
|
_reader_cmd_ntag_sig: 85, //读取ntag签名信息
|
|
_reader_cmd_icode2_set_mode: 100, //设置数据交换模式
|
_reader_cmd_icode2_inventory: 101, // ICode2卡执行防冲突操作,返回卡的 DSFID 和 UID
|
_reader_cmd_icode2_select: 102, //设置ICode2卡为选择状态.
|
_reader_cmd_icode2_reset_to_ready: 103, //使ICode2卡进入 Ready 状态
|
_reader_cmd_icode2_to_quiet: 104, //使ICode2卡进入 Quiet 状态
|
_reader_cmd_icode2_read: 105, //读取ICode2多个块信息
|
_reader_cmd_icode2_write: 106, //写入ICode2多个块信息
|
_reader_cmd_icode2_write_afi: 107, //写AFI(应用标识)
|
_reader_cmd_icode2_write_dsfid: 108, //写DSFID(数据存储标识)
|
_reader_cmd_icode2_set_eas: 109, //设置EAS
|
_reader_cmd_icode2_lock: 110, //锁定数据块
|
_reader_cmd_icode2_lock_afi: 111, //锁定AFI
|
_reader_cmd_icode2_lock_dsfid: 112, //锁定DSFID
|
_reader_cmd_icode2_lock_eas: 113, //锁定EAS
|
_reader_cmd_icode2_get_mulblock_security: 114, //读取ICode2的多个块的安全状态信息
|
_reader_cmd_icode2_get_sysinfo: 115, //获取ICode2系统信息
|
|
_reader_cmd_uhf_inventory: 120, //查找标签
|
_reader_cmd_uhf_select_mode: 121, //设置选择模式
|
_reader_cmd_uhf_select: 122, //选择标签
|
_reader_cmd_uhf_read: 123, //读标签数据存储区
|
_reader_cmd_uhf_write: 124, //写标签数据存储区
|
_reader_cmd_uhf_lock_unlock: 125, //锁定或解锁数据存储区
|
_reader_cmd_uhf_kill: 126, //灭活标签
|
_reader_cmd_uhf_set_region: 127, //设置读写器工作地区
|
_reader_cmd_uhf_set_channel: 128, //设置工作信道
|
_reader_cmd_uhf_get_channel: 129, //获取工作信道
|
_reader_cmd_uhf_set_hfss: 130, //设置自动跳频
|
_reader_cmd_uhf_set_papower: 131, //设置发射功率
|
_reader_cmd_uhf_get_papower: 132, //获取发射功率
|
_reader_cmd_uhf_set_cw: 133, //设置发射连续载波
|
_reader_cmd_uhf_set_modem: 134, //设置读写器接收解调器参数
|
_reader_cmd_uhf_get_modem: 135, //获取读写器接收解调器参数
|
|
_reader_cmd_lf_set_datarate: 150, //设置接收频率
|
_reader_cmd_lf_open_mod: 151, //打开 125KHz 射频信号
|
_reader_cmd_lf_close_mod: 152, //关闭 125KHz 射频信号
|
_reader_cmd_t5557_write_free: 153, //向射频卡中写入数据(不加密)
|
_reader_cmd_t5557_write_pwd: 154, //向射频卡中写入数据(加密)
|
_reader_cmd_t5557_read_direct: 155, //读取T5557卡中指定数据页指定数据区的数据
|
_reader_cmd_t5557_aor: 156, //使用密码唤醒 AOR 模式进行读加密的T5557射频卡
|
_reader_cmd_t5557_to_id: 157, //将 T5557 卡转换成 ID 卡
|
_reader_cmd_id_restore_t5557: 158, //将转换成的 ID 卡还原成 T5557 卡
|
_reader_cmd_em_read: 159, //读取EM4001或兼容 ID 卡数据
|
_reader_cmd_em4305_write: 160, //向 EM4305 卡指定地址写入数据
|
_reader_cmd_em4305_read_biphase: 161, //读取 EM4305 卡指定地址的数据
|
_reader_cmd_em4305_read_manchester: 162, //读取 EM4305 卡指定地址的数据
|
_reader_cmd_em4305_login: 163, //验证 EM4305 卡密码
|
_reader_cmd_em4305_protect: 164, //锁定 EM4305 卡指定地址
|
_reader_cmd_em4305_disable: 165, //休眠 EM4305 卡
|
_reader_cmd_em4305_set_mode: 166, //设置EM卡类型
|
_reader_cmd_em4305_to_id: 167, //把 EM4305 格式化成 ID 卡
|
_reader_cmd_em4305_to_fdxb: 168, //把 EM4305 格式化成 FDX_B 卡
|
|
_reader_cmd_cpu_reset: 200, //接触cpu复位
|
_reader_cmd_cpu_transmit: 201, //接触cpu发送命令
|
_reader_cmd_cpu_set_baud: 202, //设置接触cpu波特率
|
|
_reader_cmd_24c_write: 205, //写24c系列卡片
|
_reader_cmd_24c_read: 206, //读24c系列卡片
|
_reader_cmd_45D041_write: 207, //写45D041卡
|
_reader_cmd_45D041_read: 208, //读45D041卡
|
|
_reader_cmd_4442_read: 210, //读SLE4442卡
|
_reader_cmd_4442_write: 211, //写SLE4442卡
|
_reader_cmd_4442_verify_sc: 212, //验证SLE4442卡密码
|
_reader_cmd_4442_change_sc: 213, //更改SLE4442卡密码
|
_reader_cmd_4442_read_sc: 214, //读SLE4442卡密码
|
_reader_cmd_4442_read_counter: 215, //读取错误计数
|
_reader_cmd_4442_read_pro_bit: 216, //读保护位
|
_reader_cmd_4442_protect: 217, //保护数据
|
|
_reader_cmd_4428_read: 220, //读SLE4428卡
|
_reader_cmd_4428_write: 221, //写SLE4428卡
|
_reader_cmd_4428_verify_sc: 222, //验证SLE4428卡密码
|
_reader_cmd_4428_change_sc: 223, //更改SLE4428卡密码
|
_reader_cmd_4428_read_sc: 224, //读SLE4428卡密码
|
_reader_cmd_4428_read_counter: 225, //读取错误计数
|
_reader_cmd_4428_read_pro: 226, //带保护位读
|
_reader_cmd_4428_write_pro: 227, //写数据并保护
|
_reader_cmd_4428_protect: 228, //保护数据
|
|
_reader_cmd_102_read: 230, //读102卡
|
_reader_cmd_102_write: 231, //写102卡
|
_reader_cmd_102_erase: 232, //擦除数据
|
_reader_cmd_102_verify_sc: 233, //验证用户密码
|
_reader_cmd_102_change_sc: 234, //更改用户密码
|
_reader_cmd_102_read_sc: 235, //读取用户密码
|
_reader_cmd_102_read_sc_counter: 236, //读取用户密码错误计数器
|
_reader_cmd_102_verify_erase_key: 237, //校验擦除密码
|
_reader_cmd_102_change_erase_key: 238, //更改擦除密码
|
_reader_cmd_102_read_erase_key: 239, //读取擦除密码
|
_reader_cmd_102_read_erase_counter: 240, //读取应用二区擦除计数
|
_reader_cmd_102_PR_RD_clear: 241, //读写属性控制位清零
|
_reader_cmd_102_simulate_psnl: 242, //模拟个人化
|
_reader_cmd_102_psnl: 243, //个人化
|
|
_reader_cmd_1604_read: 250, //读1604卡
|
_reader_cmd_1604_write: 251, //写1604卡
|
_reader_cmd_1604_erase: 252, //擦除数据
|
_reader_cmd_1604_verify_sc: 253, //验证密码
|
_reader_cmd_1604_change_sc: 254, //更改密码
|
_reader_cmd_1604_read_sc: 255, //读取密码
|
_reader_cmd_1604_read_sc_counter: 256, //读取密码错误计数
|
_reader_cmd_1604_verify_erase_key: 257, //验证擦除密码
|
_reader_cmd_1604_change_erase_key: 258, //更改擦除密码
|
_reader_cmd_1604_read_erase_key: 259, //读取擦除密码
|
_reader_cmd_1604_read_erase_key_counter: 260, //读取擦除密码错误计数
|
_reader_cmd_1604_PR_RD_clear: 261, //读写属性控制位清零
|
_reader_cmd_1604_simulate_psnl: 262, //模拟个人化
|
_reader_cmd_1604_psnl: 263, //个人化
|
|
_reader_cmd_1608_reset: 270, //复位
|
_reader_cmd_1608_read_user: 271, //读用户区
|
_reader_cmd_1608_write_user: 272, //写用户区
|
_reader_cmd_1608_read_config: 273, //读配置区
|
_reader_cmd_1608_write_config: 274, //写配置区
|
_reader_cmd_1608_verify_pwd: 275, //校验密码
|
_reader_cmd_1608_change_pwd: 276, //更改密码
|
_reader_cmd_1608_read_pwd: 277, //读密码
|
_reader_cmd_1608_read_pwd_counter: 278, //读密码错误计数器
|
_reader_cmd_1608_read_ar: 279, //读AR(用户区访问权限寄存器)
|
_reader_cmd_1608_write_ar: 280, //写AR
|
_reader_cmd_1608_read_fuse: 281, //读熔断标志
|
_reader_cmd_1608_psnl: 282, //个人化
|
|
_reader_cmd_153_reset: 290, //复位
|
_reader_cmd_153_read_user: 291, //读用户区
|
_reader_cmd_153_write_user: 292, //写用户区
|
_reader_cmd_153_read_config: 293, //读配置区
|
_reader_cmd_153_write_config: 294, //写配置区
|
_reader_cmd_153_verify_pwd: 295, //校验密码
|
_reader_cmd_153_change_pwd: 296, //更改密码
|
_reader_cmd_153_read_pwd: 297, //读密码
|
_reader_cmd_153_read_pwd_counter: 298, //读密码错误计数器
|
_reader_cmd_153_read_ar: 299, //读AR(用户区访问权限寄存器)
|
_reader_cmd_153_write_ar: 300, //写AR
|
_reader_cmd_153_read_dcr: 301, //读DCR(设备配置寄存器)
|
_reader_cmd_153_write_dcr: 302, //写DCR
|
_reader_cmd_153_read_fuse: 303, //读熔断标志
|
_reader_cmd_153_write_fuse: 304, //写熔断标志
|
_reader_cmd_153_psnl: 305, //个人化
|
|
_reader_cmd_mag_read: 500, //读磁条卡数据
|
_reader_cmd_identity_read: 501, //读身份证信息
|
_reader_cmd_ssc_read: 502, //读社保卡基本信息
|
_reader_cmd_hc_read: 503, //读健康卡号
|
_reader_cmd_bc_read: 504 //读银行卡/信用卡号
|
|
}
|
|
var CONNECT_MODE = {
|
_connect_mode_usb: 0, //usb连接,只能连接一台
|
_connect_mode_usb_number: 1, //usb编号连接，可以连接多台
|
_connect_mode_serial_port: 2, //串口连接
|
_connect_mode_net: 3, // 网络连接
|
_connect_mode_bluetooth: 4 //蓝牙连接
|
}
|
|
/**
|
* 获取reader对象, 方法内部会自动连接ReaderService服务
|
*/
|
function getReader() {
|
var reader = {};
|
var socketOpen = false;
|
var target = null;
|
|
//callback 回调函数
|
reader.onResult = function(callback) {
|
target.addEvent("SocketRet", callback);
|
};
|
|
var WSonOpen = function() {
|
socketOpen = true;
|
|
var resultData = {
|
functionId: READER_CMD._reader_server_connect,
|
result: 0,
|
resultData: ""
|
};
|
if (target != null)
|
target.fireEvent("SocketRet", resultData);
|
|
//alert('WebSocket Open.');
|
console.log('WebSocket Open.');
|
};
|
|
var WSonMessage = function(msg) {
|
var str = msg.data.split('|');
|
var len = str.length;
|
if (str[0] != PROTOCEL_FLAG._reader_cmd_STX || str[len - 1] != PROTOCEL_FLAG._reader_cmd_ETX) {
|
return;
|
}
|
//设置回调
|
var resultData = {
|
functionId: parseInt(str[1]), //命令代码
|
result: parseInt(str[2]), //执行结果代码, 0 成功, 其它失败
|
resultData: len == 5 ? str[3] : "" //返回结果
|
};
|
|
if (target != null)
|
target.fireEvent("SocketRet", resultData);
|
};
|
|
var WSonClose = function() {
|
socketOpen = false;
|
/* var resultData = {
|
functionId: READER_CMD._reader_server_close,
|
result: 0,
|
resultData: ""
|
};
|
|
if (target != null)
|
target.fireEvent("SocketRet", resultData); */
|
|
console.log('Reader Service Close.');
|
};
|
|
var WSonError = function() {
|
/* var resultData = {
|
functionId: READER_CMD._reader_server_connect,
|
result: -1,
|
resultData: ''
|
};
|
if (target != null)
|
target.fireEvent("SocketRet", resultData); */
|
alert("Server not running");
|
};
|
|
//创建socket, 建立连接
|
(function createSocket() {
|
try {
|
if ("WebSocket" in window) {
|
socket = new WebSocket("ws://localhost:8256/ReaderWebServer/");
|
} else if ("MozWebSocket" in window) {
|
socket = new MozWebSocket("ws://localhost:8256/ReaderWebServer/");
|
} else {
|
return null;
|
}
|
socket.onopen = WSonOpen;
|
socket.onmessage = WSonMessage;
|
socket.onclose = WSonClose;
|
socket.onerror = WSonError;
|
target = new EventTarget();
|
} catch (ex) {
|
alert(ex.Message);
|
}
|
})();
|
|
var SendCmd = function(readerCmd) {
|
if (true == socketOpen) {
|
var len = readerCmd.length;
|
var entryCmd = PROTOCEL_FLAG._reader_cmd_STX + "|";
|
for (var i = 0; i < len; i++) {
|
entryCmd += readerCmd[i] + "|";
|
}
|
entryCmd += PROTOCEL_FLAG._reader_cmd_ETX;
|
socket.send(entryCmd);
|
} else {
|
alert("Server not connected.");
|
}
|
};
|
|
/********************************************************************************************************
|
******************* 数据转换方法 ************************************************************************
|
********************************************************************************************************/
|
/**
|
* 将字符串转换成16进制字符
|
* @param {string} str 要转换的字符串
|
* @returns {string} 转换后的16进制字符
|
*/
|
reader.strToHexCharCode = function(str) {
|
if (str === "")
|
return "";
|
var hexCharCode = [];
|
//hexCharCode.push("0x");
|
for (var i = 0; i < str.length; i++) {
|
hexCharCode.push((str.charCodeAt(i)).toString(16));
|
}
|
return hexCharCode.join("");
|
};
|
|
/**
|
* 将16进制字符转换为字符串
|
* @param {string} hexCharCodeStr 要转换的16进制字符
|
* @returns {string} 转换后的字符串
|
*/
|
reader.hexCharCodeToStr = function(hexCharCodeStr) {
|
var trimedStr = hexCharCodeStr.trim();
|
var rawStr =
|
trimedStr.substr(0, 2).toLowerCase() === "0x" ?
|
trimedStr.substr(2) :
|
trimedStr;
|
var len = rawStr.length;
|
if (len % 2 !== 0) {
|
alert("Illegal Format ASCII Code!");
|
return "";
|
}
|
var curCharCode;
|
var resultStr = [];
|
for (var i = 0; i < len; i = i + 2) {
|
curCharCode = parseInt(rawStr.substr(i, 2), 16); // ASCII Code Value
|
resultStr.push(String.fromCharCode(curCharCode));
|
}
|
return resultStr.join("");
|
};
|
|
/*****************************************************************************************************************
|
************ 读写器操作方法 **************************************************************************************
|
*****************************************************************************************************************/
|
/**
|
* 连接串口读写器
|
* @param {number} port 端口号, 取值 0 ~ 19, 对应端口 COM1 ~ COM20
|
* @param {number} baud 波特率, 取值 9600 ~ 115200
|
* @returns {number} 读写器句柄
|
*/
|
reader.connectSerialPort = function(port, baud) {
|
SendCmd([READER_CMD._reader_cmd_connect, CONNECT_MODE._connect_mode_serial_port, port, baud]);
|
};
|
|
/**
|
* 连接usb读写器
|
* @returns 读写器句柄
|
*/
|
reader.connectUsb = function() {
|
SendCmd([READER_CMD._reader_cmd_connect, CONNECT_MODE._connect_mode_usb]);
|
};
|
|
/**
|
* 按照usb编号连接读写器, 此方法可用于一台电脑连接多台设备的情况
|
* @param {number} n 读写器编号, 取值 0 ~ 255
|
* @returns {number} 读写器句柄
|
*/
|
reader.connectUsbNumber = function(n) {
|
SendCmd([READER_CMD._reader_cmd_connect, CONNECT_MODE._connect_mode_usb_number, n]);
|
};
|
|
/**
|
* 断开读写器连接
|
* @param {number} icdev 连接读写器返回的句柄
|
*/
|
reader.disconnect = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_disconnect, icdev]);
|
};
|
|
/**
|
* 读取硬件版本号
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 读写器硬件版本号
|
*/
|
reader.readHardwareVersion = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_read_ver, icdev]);
|
};
|
|
/**
|
* 让读写器鸣响一段时间
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} time 鸣响时间, 单位 10ms, 取值 0 ~ 255
|
*/
|
reader.readerBeep = function(icdev, time) {
|
SendCmd([READER_CMD._reader_cmd_beep, icdev, time]);
|
};
|
|
/**
|
* 读产品序列号
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 读写器的产品序列号
|
*/
|
reader.readProductSerialNumber = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_read_snr, icdev]);
|
};
|
|
/**
|
* 更改读写器的串口波特率
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} baud 要更改的串口波特率, 取值 9600 ~ 115200
|
* @description 读写器连接成功后再使用此方法更改其波特率
|
*/
|
reader.SetBaudRate = function(icdev, baud) {
|
SendCmd([READER_CMD._reader_cmd_set_baud, icdev, baud]);
|
};
|
|
/**
|
* 获取大卡座是否有卡
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {number} 读写器大卡座插卡状态, 0 -- 无卡, 1 -- 有卡
|
*/
|
reader.getReaderStatus = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_get_status, icdev]);
|
};
|
|
/**
|
* 向读写器的 EEPROM 中写入数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} offset 起始地址, 取值 0 ~ 999
|
* @param {string} data 要写入的数据, 长度 <= 2000
|
*/
|
reader.writeEEPROM = function(icdev, offset, data) {
|
SendCmd([READER_CMD._reader_cmd_write_eeprom, icdev, offset, data]);
|
};
|
|
/**
|
* 从读写器 EEPROM 中读取数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} offset 要读取的起始地址, 取值 0 ~ 999
|
* @param {number} len 要读取的数据字节长度, 取值 1 ~ 1000
|
* @returns {string} 返回读取到的数据, 长度为 len * 2.
|
*/
|
reader.readEEPROM = function(icdev, offset, len) {
|
SendCmd([READER_CMD._reader_cmd_read_eeprom, icdev, offset, len]);
|
};
|
|
/**
|
* 设置Usb读写器编号
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} number 要设置的读写器编号, 取值 0 ~ 255
|
* @description 使用连接读写器方法连接成功后, 再使用此方法设置读写器编号,
|
* 编号设置成功后, 可使用 connectUsbNumber() 方法连接指定编号的设备
|
*/
|
reader.setUsbReaderNumber = function(icdev, number) {
|
SendCmd([READER_CMD._reader_cmd_set_number, icdev, number]);
|
};
|
|
/**
|
* 获取Usb读写编号
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {number} 获取到的读写器编号
|
*/
|
reader.getUsbReaderNumber = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_get_number, icdev]);
|
};
|
|
/**
|
* 接触式卡座上电
|
* @param {number} icdev 连接读写器返回的句柄
|
*/
|
reader.turnOn = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_turn_on, icdev]);
|
};
|
|
/**
|
* 接触式卡座下电
|
* @param {number} icdev 连接读写器返回的句柄
|
*/
|
reader.turnOff = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_turn_off, icdev]);
|
};
|
|
/**
|
* 将 RF（射频 13.56MHz）先关闭一段时间后再重新打开, 此操作会让所有在天线区域的卡片都回到初始状态
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} time 复位场强射频信号时间 ( 1~ 500ms); 0 表示关闭射频场强信号
|
*/
|
reader.rfReset = function(icdev, time) {
|
SendCmd([READER_CMD._reader_cmd_rf_reset, icdev, time]);
|
};
|
|
/**
|
* 选择非接触卡协议, 读写器默认 ISO14443 TypeA 协议, 如果操作其它协议卡片, 需要选择其相应的协议
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} prot 协议类型. 0: TypeA; 1: TypeB; 2: ICODE
|
*/
|
reader.selectProtocol = function(icdev, prot) {
|
SendCmd([READER_CMD._reader_cmd_select_protocol, icdev, prot]);
|
};
|
|
/****************************************************************************************************************
|
*************** 非接卡(13.56MHZ)操作 ****************************************************************************
|
****************************************************************************************************************/
|
/**
|
* ISO14443 TypeA 协议卡片寻卡并激活, 在操作 TypeA协议卡片之前都要调用此方法
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} mode 0 -- IDLE mode, 只有处在 IDLE 状态的卡片才响应读写器的命令,配合 rfHalt()方法可防止卡片反复操作.
|
* 1 -- ALL mode, 处在 IDLE 状态和 HALT 状态的卡片都将响应读写器的命令
|
* @returns {string} 卡片序列号
|
*/
|
reader.rfCard = function(icdev, mode) {
|
SendCmd([READER_CMD._reader_cmd_rf_card, icdev, mode]);
|
};
|
|
/**
|
* 终止对 TypeA 卡的操作, 终止后卡片不会响应任何命令. 如果再次操作卡片时需要重新寻卡
|
* @param {number}} icdev 连接读写器返回的句柄
|
*/
|
reader.rfHalt = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_rf_halt, icdev]);
|
};
|
|
/**
|
* ISO14443 TypeB 协议卡片寻卡激活, 在操作 TypeB协议卡片之前都要调用此方法
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 卡片序列号
|
*/
|
reader.rfCardB = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_rf_card_b, icdev]);
|
};
|
|
/**
|
* 终止对 TypeB 卡的操作, 终止后卡片不会响应任何命令. 如果再次操作卡片时需要重新寻卡
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} snr 要终止操作的卡片的序列号
|
*/
|
reader.rfHaltB = function(icdev, snr) {
|
SendCmd([READER_CMD._reader_cmd_rf_halt_b, icdev, snr]);
|
};
|
|
/******************* S50/S70 卡操作方法 **********************/
|
// 在操作 S50/S70 卡之前需要调用 rf_card 寻卡并激活卡片
|
/**
|
* 校验 S50/S70 卡密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} mode 要验证的密码类型, 0 -- 使用KeyA验证; 4 -- 使用KeyB验证
|
* @param {number} sector 要验证的扇区号
|
* @param {string} key 要验证的扇区密码, 长度为 12.
|
*/
|
reader.mifareAuthenticationKey = function(icdev, mode, sector, key) {
|
SendCmd([READER_CMD._reader_cmd_m_auth_key, icdev, mode, sector, key]);
|
};
|
|
/**
|
* 向 s50/s70 指定块中写入数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} block 要写入数据的块号(绝对块号)
|
* @param {string} data 要写入的数据
|
*/
|
reader.mifareWrite = function(icdev, block, data) {
|
SendCmd([READER_CMD._reader_cmd_m_write, icdev, block, data]);
|
};
|
|
/**
|
* 读取 s50/s70 指定块中的数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} block 要读取数据的块号(绝对块号)
|
* @returns {string} 读取到的块数据
|
*/
|
reader.mifareRead = function(icdev, block) {
|
SendCmd([READER_CMD._reader_cmd_m_read, icdev, block]);
|
};
|
|
/**
|
* 初始化 s50/s70 块值, 对某一块进行值操作时使用的是特殊的数据结构, 如果要进行加减值操作, 需要进行初始化操作, 然后才可以读、减、加的操作
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} block 要初始化值的块号(绝对块号)
|
* @param {number} value 要初始化的值
|
*/
|
reader.mifareInitValue = function(icdev, block, value) {
|
SendCmd([READER_CMD._reader_cmd_m_init_value, icdev, block, value]);
|
};
|
|
/**
|
* 读取 s50/s70 指定块的值, 此块必须经过值初始化
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} block 要读取值的块号(绝对块号)
|
* @returns {number} 读取到的值
|
*/
|
reader.mifareReadValue = function(icdev, block) {
|
SendCmd([READER_CMD._reader_cmd_m_read_value, icdev, block]);
|
};
|
|
/**
|
* 向 s50/s70 指定块加值, 此块必须经过值初始化
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} block 要增加值的块号(绝对块号)
|
* @param {number} value 要增加的值
|
*/
|
reader.mifareIncrementValue = function(icdev, block, value) {
|
SendCmd([READER_CMD._reader_cmd_m_increment_value, icdev, block, value]);
|
};
|
|
/**
|
* s50/s70 指定块减值, 此块必须经过值初始化
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} block 要减少值的块号(绝对块号)
|
* @param {number} value 要减少的值
|
*/
|
reader.mifareDecrementValue = function(icdev, block, value) {
|
SendCmd([READER_CMD._reader_cmd_m_decrement_value, icdev, block, value]);
|
};
|
|
/****************** 非接 CPU 卡操作 *******************************************************/
|
// 在非接 CPU 卡复位之前需要调用 rf_card 寻卡并激活卡片
|
/**
|
* 非接触 TypeA CPU 卡复位, 复位之前需要进行寻卡操作
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 卡片返回的复位信息
|
*/
|
reader.mifareCpuReset = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_c_cpu_reset, icdev]);
|
};
|
|
/**
|
* 非接触 TypeB CPU 卡复位, 复位之前需要进行寻卡操作
|
* @param {number} icdev 连接读写器返回的句柄
|
*/
|
reader.mifareCpuResetB = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_c_cpu_reset_b, icdev]);
|
};
|
|
/**
|
* 非接 TypeA/B CPU 卡发送指令
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} cmd 要发送的 cos 指令
|
* @returns {string} 卡片返回的应答信息, 包含sw1sw2
|
*/
|
reader.mifareCpuTransmit = function(icdev, cmd) {
|
SendCmd([READER_CMD._reader_cmd_c_cpu_Transmit, icdev, cmd]);
|
};
|
|
/******************** Ultralight / Ultralight C / Ultralight EV 卡操作 *******************/
|
// 在操作 Ultralight / Ultralight C / Ultralight EV 卡之前需要调用 rf_card 寻卡并激活卡片
|
/**
|
* 校验 ultralight C 密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} key 密码, 长度 32.
|
*/
|
reader.ulcAuthenticationKey = function(icdev, key) {
|
SendCmd([READER_CMD._reader_cmd_uc_auth_key, icdev, key]);
|
};
|
|
/**
|
* 校验 ultralight EV 密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} key 密码, 长度 8.
|
*/
|
reader.ulevAuthenticationKey = function(icdev, key) {
|
SendCmd([READER_CMD._reader_cmd_uev_auth_key, icdev, key]);
|
};
|
|
/**
|
* 读 ultralight 及 ultralight C 数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} block 要读取数据的块号, Ultralight 取值 0 ~ 15; Ultralight C 取值 0 ~ 43.
|
* @returns {string} 读取到的数据
|
*/
|
reader.ulcRead = function(icdev, block) {
|
SendCmd([READER_CMD._reader_cmd_u_read, icdev, block]);
|
};
|
|
/**
|
* 向 ultralight 及 ultralight C 写入数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} block 要写入数据的块号, Ultralight 取值 0 ~ 15; Ultralight C 取值 0 ~ 43.
|
* @param {string} data 要写入的数据, 长度为 8, 不足补 0.
|
*/
|
reader.ulcWrite = function(icdev, block, data) {
|
SendCmd([READER_CMD._reader_cmd_u_write, icdev, block, data]);
|
};
|
|
/**
|
* 更改 ultralight C 密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} key 要更改的新密码, 长度为 8.
|
*/
|
reader.ulcChangeKey = function(icdev, key) {
|
SendCmd([READER_CMD._reader_cmd_uc_change_key, icdev, key]);
|
};
|
|
/********************** NTAG213/215/216 标签操作**********************************************/
|
// 在操作 NTAG213/215/216 标签之前需要调用 rf_card 寻卡并激活卡片
|
/**
|
* 校验 ntag213/214/216 密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} pwd 要更改的新密码, 长度为 8.
|
*/
|
reader.ntagAuthenticationPassword = function(icdev, pwd) {
|
SendCmd([READER_CMD._reader_cmd_ntag_auth_pwd, icdev, pwd]);
|
};
|
|
/**
|
* 读 ntag213/214/216 数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} page 要读取数据的页地址. NTAG213 取值范围 0 ~ 44; NTAG215 取值范围 0 ~ 134; NTAG216 取值范围 0 ~ 230.
|
* @returns {string} 读取到的数据
|
*/
|
reader.ntagRead = function(icdev, page) {
|
SendCmd([READER_CMD._reader_cmd_ntag_read, icdev, page]);
|
};
|
|
/**
|
* 向 ntag213/214/216 中写入数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} page 要写入数据的页地址. NTAG213 取值范围 0 ~ 44; NTAG215 取值范围 0 ~ 134; NTAG216 取值范围 0 ~ 230.
|
* @param {string} data 要写入的数据, 长度为 8, 不足补 0.
|
*/
|
reader.ntagWrite = function(icdev, page, data) {
|
SendCmd([READER_CMD._reader_cmd_ntag_write, icdev, page, data]);
|
};
|
|
/**
|
* 读ntag中nfc单向计数器的值
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} number 计数器编号
|
* @returns {number} 读取到的计数器的值.
|
*/
|
reader.ntagGetCounter = function(icdev, number) {
|
SendCmd([READER_CMD._reader_cmd_ntag_counter, icdev, number]);
|
};
|
|
/**
|
* 读ntag版本信息
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 读取到的版本信息
|
*/
|
reader.ntagReadVersion = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_ntag_version, icdev]);
|
};
|
|
/**
|
* 读取ntag签名信息
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 读取到的签名信息
|
*/
|
reader.ntagReadSIG = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_ntag_sig, icdev]);
|
};
|
|
/************ ISO15693(ICODE2) 卡操作 ***********************************************************************/
|
//注: 读写器默认协议类型为 ISO14443 TypeA, 在操作 ICODE2 之前请使用 selectProtocol() 选择协议类型
|
/**
|
* 设置数据交换模式
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} mode 数据交换模式: 0 -- 标准模式, 波特率为 26.5 kbit; 1 -- 快模式, 波特率为 53 kbit/s
|
*/
|
reader.icode2SetMode = function(icdev, mode) {
|
SendCmd([READER_CMD._reader_cmd_icode2_set_mode, icdev, mode]);
|
};
|
|
/**
|
* ICode2寻卡并执行防冲突操作,返回卡的 DSFID 和 UID
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} afi_flag 是否匹配 AFI 值. 0 -- 否; 1 -- 是.
|
* @param {number} afi AFI 的值.
|
* @param {number} slot_flag 通道类型. 0 -- 16 通道, 可以操作天线范围内的多张卡; 1 -- 1 通道, 只能操作一张卡
|
* @returns {string} 卡片应答信息. 多张卡使用 # 号隔开, 每张卡数据使用 * 号隔开, * 号之前为 DSFID 的值(number, 10进制), * 号之后为卡 UID.
|
* @example 12*abcdef1234567890#34*1234567890abcdef 表示有 2 张卡,
|
* 卡 1 的 UID 为 abcdef1234567890, DSFID 为 12; 卡 2 的 UID 为 1234567890abcdef, DSFID 为 34.
|
*/
|
reader.icode2Inventory = function(icdev, afi_flag, afi, slot_flag) {
|
SendCmd([READER_CMD._reader_cmd_icode2_inventory, icdev, afi_flag, afi, slot_flag]);
|
};
|
|
/**
|
* 设置 ICODE2 卡为选择状态.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} uid 要设置为选择状态卡的 UID, 长度为 16.
|
*/
|
reader.icode2Select = function(icdev, uid) {
|
SendCmd([READER_CMD._reader_cmd_icode2_select, icdev, uid]);
|
};
|
|
/**
|
* 使 ICODE2 卡进入 Ready 状态
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} select_flag 0 -- 根据 address_flag 的设置选择卡来执行该命令; 1 -- 只有选择状态下的卡能执行该命令
|
* @param {number} address_flag 0 -- 请求不是地址模式, UID 无效, 任何卡都执行; 1 -- 请求是地址模式, UID 有较, 只有 UID 匹配的卡才执行该命令
|
* @param {string} uid 要设置为 Ready 状态的卡片 UID, 长度为 16.
|
*/
|
reader.icode2Ready = function(icdev, select_flag, address_flag, uid) {
|
SendCmd([READER_CMD._reader_cmd_icode2_reset_to_ready, icdev, select_flag, address_flag, uid]);
|
};
|
|
/**
|
* 使 ICODE2 卡进入 Quiet 状态,卡片进入 Quiet 状态后不会响应任何命令
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} uid 要设置为 Quiet 状态的卡片 UID, 长度为 16.
|
*/
|
reader.icode2Quiet = function(icdev, uid) {
|
SendCmd([READER_CMD._reader_cmd_icode2_to_quiet, icdev, uid]);
|
};
|
|
/**
|
* 读取 ICODE2 多个块数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} select_flag 0 -- 根据 address_flag 的设置选择卡来执行该命令; 1 -- 只有选择状态下的卡能执行该命令
|
* @param {number} address_flag 0 -- 请求不是地址模式, UID 无效, 任何卡都执行; 1 -- 请求是地址模式, UID 有较, 只有 UID 匹配的卡才执行该命令
|
* @param {number} option_flag 0 -- 卡不返回块的安全状态; 1 -- 返回块的安全状态.
|
* @param {number} startBlock 要读取数据的起始块号, 取值 0 ~ 27.
|
* @param {number} blockNumber 读取的块数量
|
* @param {string} uid 要读取数据的卡片 UID, 长度为 16.
|
* @returns {string} 读取到的数据. 当 option_flag = 0 时, 每 8 位为一个块的数据, 当 option_flag = 1 时, 每 10 位为一个块的数据(包含安全状态),
|
* 其中前两位为安全状态, 如果为 '00' 表示此块未锁, 可以读写数据, 如果为 '01' 表示此块已锁, 只可读不可写.
|
* @example 从 0 块开始读取 2 个块的数据, 即读取 0, 1 两个块的数据,
|
* 如果不返回安全状态, 数据为 '1234567890ABCDEF', 其中 '12345678' 为 0 块数据, '90ABCDEF' 为 1 块数据.
|
* 如果返回安全状态, 数据为 '00123456780190ABCDEF', 其中 '0012345678' 为 0 块安全状态和数据, 前两个字符 '00' 表示此块未锁, 后面数据为 0 块数据;
|
* '0190ABCDEF' 为 1 块安全状态和数据, 前两个字符 '01' 表示此块已锁, 后面数据为 1 块数据.
|
*
|
*/
|
reader.icode2Read = function(icdev, select_flag, address_flag, option_flag, startBlock, blockNumber, uid) {
|
SendCmd([READER_CMD._reader_cmd_icode2_read, icdev, select_flag, address_flag, option_flag, startBlock, blockNumber, uid]);
|
};
|
|
/**
|
* 向 ICODE2 多个块写入数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} select_flag 0 -- 根据 address_flag 的设置选择卡来执行该命令; 1 -- 只有选择状态下的卡能执行该命令
|
* @param {number} address_flag 0 -- 请求不是地址模式, UID 无效, 任何卡都执行; 1 -- 请求是地址模式, UID 有较, 只有 UID 匹配的卡才执行该命令
|
* @param {number} startBlock 要写入数据的起始块号, 取值 0 ~ 27.
|
* @param {number} blockNumber 写入的块数量
|
* @param {string} uid 要写入数据的卡片 UID, 长度为 16.
|
* @param {string} data 要写入的数据, 长度为 blockNumber * 8, 不足补 0.
|
*/
|
reader.icode2Write = function(icdev, select_flag, address_flag, startBlock, blockNumber, uid, data) {
|
SendCmd([READER_CMD._reader_cmd_icode2_write, icdev, select_flag, address_flag, startBlock, blockNumber, uid, data]);
|
};
|
|
/**
|
* 写 AFI (应用标识)
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} select_flag 0 -- 根据 address_flag 的设置选择卡来执行该命令; 1 -- 只有选择状态下的卡能执行该命令
|
* @param {number} address_flag 0 -- 请求不是地址模式, UID 无效, 任何卡都执行; 1 -- 请求是地址模式, UID 有较, 只有 UID 匹配的卡才执行该命令
|
* @param {string} uid 要写 AFI 的卡片 UID, 长度为 16.
|
* @param {string} afi AFI 的值
|
*/
|
reader.icode2WriteAFI = function(icdev, select_flag, address_flag, uid, afi) {
|
SendCmd([READER_CMD._reader_cmd_icode2_write_afi, icdev, select_flag, address_flag, uid, afi]);
|
};
|
|
/**
|
* 写 DSFID (数据存储标识)
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} select_flag 0 -- 根据 address_flag 的设置选择卡来执行该命令; 1 -- 只有选择状态下的卡能执行该命令
|
* @param {number} address_flag 0 -- 请求不是地址模式, UID 无效, 任何卡都执行; 1 -- 请求是地址模式, UID 有较, 只有 UID 匹配的卡才执行该命令
|
* @param {string} uid 要写 DSFID 的卡片 UID, 长度为 16.
|
* @param {string} dsfid DSFID 的值.
|
*/
|
reader.icode2WriteDSFID = function(icdev, select_flag, address_flag, uid, dsfid) {
|
SendCmd([READER_CMD._reader_cmd_icode2_write_dsfid, icdev, select_flag, address_flag, uid, dsfid]);
|
};
|
|
/**
|
* 设置 EAS
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} mode 请求标记. 0 -- 请求能被任何的卡执行; 1 -- 只被选择状态下的卡执行
|
* @param {number} eas 0 -- 设置 EAS 位为 0; 1 -- 设置 EAS 位为 1.
|
*/
|
reader.icode2SetEAS = function(icdev, mode, eas) {
|
SendCmd([READER_CMD._reader_cmd_icode2_set_eas, icdev, mode, eas]);
|
};
|
|
/**
|
* 永久锁定 ICODE2 数据块
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} select_flag 0 -- 根据 address_flag 的设置选择卡来执行该命令; 1 -- 只有选择状态下的卡能执行该命令
|
* @param {number} address_flag 0 -- 请求不是地址模式, UID 无效, 任何卡都执行; 1 -- 请求是地址模式, UID 有较, 只有 UID 匹配的卡才执行该命令
|
* @param {string} uid 要锁定的卡片 UID, 长度为 16.
|
* @param {numer} block 要锁定的块号, 取值 0 ~ 27.
|
*/
|
reader.icode2Lock = function(icdev, select_flag, address_flag, uid, block) {
|
SendCmd([READER_CMD._reader_cmd_icode2_lock, icdev, select_flag, address_flag, uid, block]);
|
};
|
|
/**
|
* 锁定 ICODE2 卡的 AFI (应用标识)
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} select_flag 0 -- 根据 address_flag 的设置选择卡来执行该命令; 1 -- 只有选择状态下的卡能执行该命令
|
* @param {number} address_flag 0 -- 请求不是地址模式, UID 无效, 任何卡都执行; 1 -- 请求是地址模式, UID 有较, 只有 UID 匹配的卡才执行该命令
|
* @param {string} uid 要锁定 AFI 的卡片 UID, 长度为 16.
|
*/
|
reader.icode2LockAFI = function(icdev, select_flag, address_flag, uid) {
|
SendCmd([READER_CMD._reader_cmd_icode2_lock_afi, icdev, select_flag, address_flag, uid]);
|
};
|
|
/**
|
* 锁定 ICODE2 卡的 DSFID (数据存储标识)
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} select_flag 0 -- 根据 address_flag 的设置选择卡来执行该命令; 1 -- 只有选择状态下的卡能执行该命令
|
* @param {number} address_flag 0 -- 请求不是地址模式, UID 无效, 任何卡都执行; 1 -- 请求是地址模式, UID 有较, 只有 UID 匹配的卡才执行该命令
|
* @param {string} uid 要锁定 DSFID 的卡片 UID, 长度为 16.
|
*/
|
reader.icode2LockDSFID = function(icdev, select_flag, address_flag, uid) {
|
SendCmd([READER_CMD._reader_cmd_icode2_lock_dsfid, icdev, select_flag, address_flag, uid]);
|
};
|
|
/**
|
* 锁定 ICODE2 卡 EAS
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} mode 请求标记. 0 -- 请求能被任何的卡执行; 1 -- 只被选择状态下的卡执行
|
*/
|
reader.icode2LockEAS = function(icdev, mode) {
|
SendCmd([READER_CMD._reader_cmd_icode2_lock_eas, icdev, mode]);
|
};
|
/*
|
//读取ICode2的多个块的安全状态信息
|
reader.icode2GetSecurity = function(icdev, select_flag, address_flag, startBlock, blockNumber, uid) {
|
SendCmd([READER_CMD._reader_cmd_icode2_get_mulblock_security, icdev, select_flag, address_flag, startBlock, blockNumber, uid]);
|
};
|
|
//获取ICode2系统信息
|
reader.icode2GetSysInfo = function(icdev, select_flag, address_flag, uid) {
|
SendCmd([READER_CMD._reader_cmd_icode2_get_sysinfo, icdev, select_flag, address_flag, uid]);
|
};*/
|
|
/***************************************************************************************************************************
|
************************** 超高频(900MHZ) 操作 *****************************************************************************
|
***************************************************************************************************************************/
|
/**
|
* 查找标签
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 返回标签的RSSI, CRC, PC, EPC, 分别用 # 号隔开
|
* RSSI 反映的是芯片输入端信号大小,不包含天线增益和定向耦合器衰减等. RSSI 为芯片输入端信号强度, 十六进制有符号数, 单位为 dBm. 如 RSSI 为 0xC9, 代表芯片输入端信号强度为-55dBm.
|
* CRC 为 标签的循环冗余校验, PC 为标签的协议控制, EPC 为标签的产品电子代码.
|
* @example 返回数据为 'C9#D3#3400#1234567890ABCDEF12345678' 则 C9 为RSSI, D3为 CRC, 3400 为 PC, 1234567890ABCDEF12345678 为EPC.
|
*/
|
reader.uhfInventory = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_uhf_inventory, icdev]);
|
};
|
|
/**
|
* 设置选择模式
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} mode 0x00 -- 在对标签的所有操作之前都预先发送 Select 指令选取特定的标签.
|
* 0x01 -- 在对标签操作之前不发送 Select 指令.
|
* 0x02 -- 仅对除轮询 Inventory 之外的标签操作之前发送 Select 指令, 如在 Read, Write, Lock, Kill 之前先通过 Select 选取特定的标签
|
*/
|
reader.uhfSetSelectMode = function(icdev, mode) {
|
SendCmd([READER_CMD._reader_cmd_uhf_select_mode, icdev, mode]);
|
};
|
|
/**
|
* 选择标签并且同时设置 Select 模式为 0x02.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} epc 要选择的标签 EPC
|
*/
|
reader.uhfSelect = function(icdev, epc) {
|
SendCmd([READER_CMD._reader_cmd_uhf_select, icdev, epc]);
|
};
|
|
/**
|
* 读取标签数据存储区 Memory Bank 中指定地址和长度的数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} pwd Access password, 长度 8.
|
* @param {number} memBank 所要读取的区域. 0 -- RFU 区; 1 -- EPC 区; 2 -- TID 区; 3 -- User 区
|
* @param {number} offset 读取的起始地址,以 word 为单位即 2 个 Byte/16 个 Bit
|
* @param {number} len 要读取的长度, 以 word 为单位即 2 个 Byte/16 个 Bit
|
* @returns {string} 返回读取到的数据, 所操作标签的 PC 及 EPC, 用 # 号隔开
|
*/
|
reader.uhfRead = function(icdev, pwd, memBank, offset, len) {
|
SendCmd([READER_CMD._reader_cmd_uhf_read, icdev, pwd, memBank, offset, len]);
|
};
|
|
/**
|
* 向标签数据存储区 Memory Bank 中指定地址写入数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} pwd Access password, 长度 8.
|
* @param {number} memBank 所要写入的区域. 0 -- RFU 区; 1 -- EPC 区; 2 -- TID 区; 3 -- User 区
|
* @param {number} offset 写入的起始地址,以 word 为单位即 2 个 Byte/16 个 Bit
|
* @param {string} data 要写入的数据, 长度必须为 4 的倍数
|
* @returns {string} 返回所操作标签的 PC 及 EPC, 用 # 号隔开
|
*/
|
reader.uhfWrite = function(icdev, pwd, memBank, offset, data) {
|
SendCmd([READER_CMD._reader_cmd_uhf_write, icdev, pwd, memBank, offset, data]);
|
};
|
|
/**
|
* 锁定或解锁数据存储区
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} pwd Access password, 长度 8.
|
* @param {string} lockData 锁定数据参数, 长度 6.
|
*/
|
reader.uhfSetLock = function(icdev, pwd, lockData) {
|
SendCmd([READER_CMD._reader_cmd_uhf_lock_unlock, icdev, pwd, lockData]);
|
};
|
|
/**
|
* 灭活 Kill 标签, 灭活后卡片需要重新 Inventory 才可操作.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} killPwd Kill Password. 标签如果没有设置过 Kill Password 密码, 即 Kill Password 密码全为 0, 按照 Gen2 协议, 标签不会被 Kill
|
*/
|
reader.uhfKill = function(icdev, killPwd) {
|
SendCmd([READER_CMD._reader_cmd_uhf_kill, icdev, killPwd]);
|
};
|
|
/**
|
* 设置读写器工作地区
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} regionCode 要设置的工作区域代码. 1 -- 中国 900MHz; 4 -- 中国 800MHz; 2 -- 美国; 3 -- 欧洲; 6 -- 韩国.
|
*/
|
reader.uhfSetRegion = function(icdev, regionCode) {
|
SendCmd([READER_CMD._reader_cmd_uhf_set_region, icdev, regionCode]);
|
};
|
|
/**
|
* 设置工作信道
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} chIndex 信道代号 CH_Index, 计算公式如下:
|
* 中国 900MHz 信道参数计算公式, Freq_CH 为信道频率： CH_Index = (Freq_CH-920.125M)/0.25M
|
* 中国 800MHz 信道参数计算公式, Freq_CH 为信道频率： CH_Index = (Freq_CH-840.125M)/0.25M<
|
* 美国信道参数计算公式, Freq_CH 为信道频率： CH_Index = (Freq_CH-902.25M)/0.5M
|
* 欧洲信道参数计算公式, Freq_CH 为信道频率： CH_Index = (Freq_CH-865.1M)/0.2M
|
* 韩国信道参数计算公式, Freq_CH 为信道频率： CH_Index = (Freq_CH-917.1M)/0.2M
|
*/
|
reader.uhfSetChannel = function(icdev, chIndex) {
|
SendCmd([READER_CMD._reader_cmd_uhf_set_channel, icdev, chIndex]);
|
};
|
|
/**
|
* 获取工作信道
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {number} 返回工作信道代码 CH_Index, 计算公式如下:
|
* 中国 900MHz 信道参数计算公式, Freq_CH 为信道频率： Freq_CH = CH_Index* 0.25M + 920.125M
|
* 中国 800MHz 信道参数计算公式, Freq_CH 为信道频率： Freq_CH = CH_Index* 0.25M + 840.125M
|
* 美国信道参数计算公式, Freq_CH 为信道频率： Freq_CH = CH_Index* 0.5M + 902.25M
|
* 欧洲信道参数计算公式, Freq_CH 为信道频率： Freq_CH = CH_Index* 0.2M + 865.1M
|
* 韩国信道参数计算公式, Freq_CH 为信道频率： Freq_CH = CH_Index* 0.2M + 917.1M
|
*/
|
reader.uhfGetChannel = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_uhf_get_channel, icdev]);
|
};
|
|
/**
|
* 设置自动跳频
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} hfss 0 -- 取消自动跳频; 1 -- 设置自动跳频
|
*/
|
reader.uhfSetHFSS = function(icdev, hfss) {
|
SendCmd([READER_CMD._reader_cmd_uhf_set_hfss, icdev, hfss]);
|
};
|
|
/**
|
* 设置发射功率
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} papower 读写器的发射功率, 如2000, 即 20dBm
|
*/
|
reader.uhfSetPapower = function(icdev, papower) {
|
SendCmd([READER_CMD._reader_cmd_uhf_set_papower, icdev, papower]);
|
};
|
|
/**
|
* 获取发射功率
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {number} 获取到的发射功率, 如2000, 即 20dBm
|
*/
|
reader.uhfGetPapower = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_uhf_get_papower, icdev]);
|
};
|
|
/**
|
* 设置发射连续载波
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} cw 0 -- 关闭连续载波; 1 -- 打开连续载波
|
*/
|
reader.uhfSetCW = function(icdev, cw) {
|
SendCmd([READER_CMD._reader_cmd_uhf_set_cw, icdev, cw]);
|
};
|
|
/**
|
* 设置读写器接收解调器参数
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} modemParam 要设置的接收解调器参数, 分别为混频器 Mixer 增益(长度为 2), 中频放大器 IFAMP 增益 IF_G(长度为 2) 及信号解调阈值 Thrd(长度为 4)
|
* 例如: '030601B0' 其中 03 为混频器 Mixer 增益 9dB; 06 为中频放大器 IFAMP 增益 36dB;
|
* 01B0为信号解调阈值 Thrd. 信号解调阈值越小能解调的标签返回 RSSI 越低, 但越不稳定, 低于一定值完全不能解调;
|
* 相反阈值越大能解调的标签返回信号 RSSI 越大, 距离越近, 越稳定. 0x01B0 是推荐的最小值
|
*/
|
reader.uhfSetModem = function(icdev, modemParam) {
|
SendCmd([READER_CMD._reader_cmd_uhf_set_modem, icdev, modemParam]);
|
};
|
|
/**
|
* 获取读写器接收解调器参数
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 获取到的接收解调器参数, 分别为混频器 Mixer 增益(长度为 2), 中频放大器 IFAMP 增益 IF_G(长度为 2) 及信号解调阈值 Thrd(长度为 4)
|
* 例如: '030601B0' 其中 03 为混频器 Mixer 增益 9dB; 06 为中频放大器 IFAMP 增益 36dB;
|
* 01B0为信号解调阈值 Thrd. 信号解调阈值越小能解调的标签返回 RSSI 越低, 但越不稳定, 低于一定值完全不能解调;
|
* 相反阈值越大能解调的标签返回信号 RSSI 越大, 距离越近, 越稳定. 0x01B0 是推荐的最小值
|
*/
|
reader.uhfGetModem = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_uhf_get_modem, icdev]);
|
};
|
|
/*******************************************************************************************************
|
******************* 低频卡(125KHZ)操作 *************************************************************************
|
*******************************************************************************************************/
|
/**
|
* 设置接收频率
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} rateCode 接收频率代码. 0 -- 1/8; 1 -- 1/16; 2 -- 1/32; 3 -- 1/40; 4 -- 1/50; 5 -- 1/64; 6 -- 1/100; 7 -- 1/128.
|
*/
|
reader.lfSetDatarate = function(icdev, rateCode) {
|
SendCmd([READER_CMD._reader_cmd_lf_set_datarate, icdev, rateCode]);
|
};
|
|
/**
|
* 打开 125KHz 射频信号
|
* @param {number} icdev 连接读写器返回的句柄
|
*/
|
reader.lfOpenMod = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_lf_open_mod, icdev]);
|
};
|
|
/**
|
* 关闭 125KHz 射频信号
|
* @param {number} icdev 连接读写器返回的句柄
|
*/
|
reader.lfCloseMod = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_lf_close_mod, icdev]);
|
};
|
|
/************* T5557 卡操作 ************************************************/
|
/**
|
* 向 T5557 射频卡中写入数据(不加密)
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} page 写入数据所在的数据页地址. 取值范围应该为1（厂商代码区）或者为0（用户数据区）
|
* @param {number} block 写入数据的数据块号. 当 page = 1 时取值 1 或 2, 当 page = 0 时, 取值 0 ~ 7.
|
* @param {number} lockBit 是否在写入同时将该数据块数据锁定, 如果锁定该块数据将不能再进行修改. 0 -- 不锁定数据块, 1 -- 锁定数据块.
|
* @param {string} data 要写入的数据, 长度为 8, 不足补 0.
|
*/
|
reader.t5557WriteFree = function(icdev, page, block, lockBit, data) {
|
SendCmd([READER_CMD._reader_cmd_t5557_write_free, icdev, page, block, lockBit, data]);
|
};
|
|
/**
|
* 向 T5557 射频卡中写入数据(加密)
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} page 写入数据所在的数据页地址. 取值范围应该为1（厂商代码区）或者为0（用户数据区）
|
* @param {number} block 写入数据的数据块号. 当 page = 1 时取值 1 或 2, 当 page = 0 时, 取值 0 ~ 7.
|
* @param {number} lockBit 是否在写入同时将该数据块数据锁定, 如果锁定该块数据将不能再进行修改. 0 -- 不锁定数据块, 1 -- 锁定数据块.
|
* @param {string} pwd 要加密的密码, 长度为 8.
|
* @param {string} data 要写入的数据, 长度为 8, 不足补 0.
|
*/
|
reader.t5557WritePwd = function(icdev, page, block, lockBit, pwd, data) {
|
SendCmd([READER_CMD._reader_cmd_t5557_write_pwd, icdev, page, block, lockBit, pwd, data]);
|
};
|
|
|
/**
|
* 读取 T5557 卡中指定数据页指定数据区的数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} page 读取数据所在的数据页地址. 取值范围应该为1（厂商代码区）或者为0（用户数据区）
|
* @param {number} block 读取数据的数据块号. 当 page = 0 时取值 1 或 2, 当 page = 1 时, 取值 0 ~ 7.
|
* @param {number} aorbit 是否在读取之前先用密码唤醒卡片. 0 -- 不唤醒卡片; 1 -- 唤醒卡片
|
* @param {string} pwd 卡密码, 长度为 8.（如卡片密码无效, 则可提供 8 个长度的任意值）
|
* @returns {string} 读取到的数据
|
*/
|
reader.t5557ReadDirect = function(icdev, page, block, aorbit, pwd) {
|
SendCmd([READER_CMD._reader_cmd_t5557_read_direct, icdev, page, block, aorbit, pwd]);
|
};
|
|
/**
|
* 使用密码唤醒 AOR 模式进行读加密的 T5557 射频卡
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} pwd 卡密码, 长度为 8.
|
*/
|
reader.t5557Aor = function(icdev, pwd) {
|
SendCmd([READER_CMD._reader_cmd_t5557_aor, icdev, pwd]);
|
};
|
|
/**
|
* 将 T5557 卡转换成 ID 卡
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} cardId 设置转换后的 ID 卡的卡号, 长度为 10.
|
*/
|
reader.t5557toID = function(icdev, cardId) {
|
SendCmd([READER_CMD._reader_cmd_t5557_to_id, icdev, cardId]);
|
};
|
|
/**
|
* 将转换成的 ID 卡还原成 T5557 卡
|
* @param {number} icdev 连接读写器返回的句柄
|
*/
|
reader.idRestoreT5557 = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_id_restore_t5557, icdev]);
|
};
|
|
/*************** EM4001 / EM4305 卡操作******************************************************/
|
/**
|
* 读取EM4001或兼容 ID 卡的卡号
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 读取到的卡号
|
*/
|
reader.em4001Read = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_em_read, icdev]);
|
};
|
|
/**
|
* 向 EM4305 卡指定地址写入数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} addr 要写入数据的地址, 取值 0 ~ 13.
|
* @param {string} data 要写入的数据, 长度为 8, 不足补 0.
|
*/
|
reader.em4305Write = function(icdev, addr, data) {
|
SendCmd([READER_CMD._reader_cmd_em4305_write, icdev, addr, data]);
|
};
|
|
/**
|
* 读取 EM4305 卡指定地址的数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} addr 要读取数据的地址, 取值 0 ~ 13.
|
* @returns {string} 返回读取到的数据
|
*/
|
reader.em4305ReadBiphase = function(icdev, addr) {
|
SendCmd([READER_CMD._reader_cmd_em4305_read_biphase, icdev, addr]);
|
};
|
|
/**
|
* 读取 EM4305 卡指定地址的数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} addr 要读取数据的地址, 取值 0 ~ 13.
|
* @returns {string} 返回读取到的数据
|
*/
|
reader.em4305ReadManchester = function(icdev, addr) {
|
SendCmd([READER_CMD._reader_cmd_em4305_read_manchester, icdev, addr]);
|
};
|
|
/**
|
* 验证 EM4305 卡密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} pwd 卡片密码, 长度为 8.
|
*/
|
reader.em4305Login = function(icdev, pwd) {
|
SendCmd([READER_CMD._reader_cmd_em4305_login, icdev, pwd]);
|
};
|
|
/**
|
* 锁定 EM4305 卡指定地址, 锁定后数据无法更改, 不可解锁.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} addr 锁定的起始地址.
|
* @param {number} addrNumber 要锁定的地址数量.
|
*/
|
reader.em4305Protect = function(icdev, addr, addrNumber) {
|
SendCmd([READER_CMD._reader_cmd_em4305_protect, icdev, addr, addrNumber]);
|
};
|
|
/**
|
* 休眠 EM4305 卡
|
* @param {number} icdev 连接读写器返回的句柄
|
*/
|
reader.em4305Disable = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_em4305_disable, icdev]);
|
};
|
|
/**
|
* 设置 EM 卡类型
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} mode 0 - Manchester RF/64; 1 - Manchester RF/32; 2 - Bi-phase RF/32
|
*/
|
reader.em4305SetMode = function(icdev, mode) {
|
SendCmd([READER_CMD._reader_cmd_em4305_set_mode, icdev, mode]);
|
};
|
|
/**
|
* 把 EM4305 格式化成 ID 卡
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} isLock 是否锁卡. 0为不加密, 1为加密, 把卡片加密,使得他人无法修改ID卡号
|
* @param {string} lockPwd 锁卡密码, 长度 8.
|
* @param {string} cardNo 格式化成 ID 卡的卡号, 长度 10.
|
*/
|
reader.em4305ToId = function(icdev, isLock, lockPwd, cardNo) {
|
SendCmd([READER_CMD._reader_cmd_em4305_to_id, icdev, isLock, lockPwd, cardNo]);
|
};
|
/*//把 EM4305 格式化成 FDX_B 卡
|
reader.em4305ToFdxb = function(icdev, isLock, lockPwd, cardNo) {
|
SendCmd([READER_CMD._reader_cmd_em4305_to_fdxb, icdev, isLock, lockPwd, cardNo]);
|
};*/
|
|
|
/*********************************************************************************************************
|
******************** 接触式卡 ****************************************************************************
|
*********************************************************************************************************/
|
|
/********** 接触 CPU 卡操作 ***************************************************/
|
/**
|
* 接触式 CPU 卡复位
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} slot 卡座编号, 0 -- CPU 大卡座; 1 -- SAM1; 2 -- SAM2; 3 -- SAM3; 4 -- SAM4
|
* @returns {string} 卡片返回的复位信息
|
*/
|
reader.cpuReset = function(icdev, slot) {
|
SendCmd([READER_CMD._reader_cmd_cpu_reset, icdev, slot]);
|
};
|
|
/**
|
* 接触式 CPU 卡发送指令
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} slot 卡座编号, 0 -- CPU 大卡座; 1 -- SAM1; 2 -- SAM2; 3 -- SAM3; 4 -- SAM4
|
* @param {string} cmd 要发送的 cos 指令
|
* @returns {string} 卡片返回的应答信息, 包含sw1sw2
|
*/
|
reader.cpuTransmit = function(icdev, slot, cmd) {
|
SendCmd([READER_CMD._reader_cmd_cpu_transmit, icdev, slot, cmd]);
|
};
|
|
/**
|
* 设置接触 cpu 波特率
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} slot 卡座编号, 0 -- CPU 大卡座; 1 -- SAM1; 2 -- SAM2; 3 -- SAM3; 4 -- SAM4
|
* @param {number} baud 要更改的新的波特率, 取值 9600/19200/38400
|
*/
|
reader.cpuSetBaud = function(icdev, slot, baud) {
|
SendCmd([READER_CMD._reader_cmd_cpu_set_baud, icdev, slot, baud]);
|
};
|
|
/************ AT24C 系列卡操作 ***************************************************************/
|
/**
|
* 写 AT24C 系列卡片
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} cardtype 卡类型编号. 1 -- AT24C01A; 2 -- AT24C02; 4 -- AT24C04; 8 -- AT24C08; 16 -- AT24C16;
|
* 32 -- AT24C32; 64 -- AT24C64; 128 -- AT24C128; 256 -- AT24C256; 512 -- AT24C512; 1024 -- AT24C1024
|
* @param {number} offset 写入数据的起始地址.
|
* @param {string} data 要写入的数据.
|
*/
|
reader.at24cWrite = function(icdev, cardtype, offset, data) {
|
SendCmd([READER_CMD._reader_cmd_24c_write, icdev, cardtype, offset, data]);
|
};
|
|
/**
|
* 读 AT24C 系列卡片
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} cardtype 卡类型编号. 1 -- AT24C01A; 2 -- AT24C02; 4 -- AT24C04; 8 -- AT24C08; 16 -- AT24C16;
|
* 32 -- AT24C32; 64 -- AT24C64; 128 -- AT24C128; 256 -- AT24C256; 512 -- AT24C512; 1024 -- AT24C1024
|
* @param {number} offset 读取数据的起始地址.
|
* @param {number} len 读取数据的字节长度
|
* @returns {string} 读取到的数据, 长度为 len * 2.
|
*/
|
reader.at24cRead = function(icdev, cardtype, offset, len) {
|
SendCmd([READER_CMD._reader_cmd_24c_read, icdev, cardtype, offset, len]);
|
};
|
|
/************ AT45D041 卡操作 ***************************************************************/
|
/**
|
* 写 AT45D041 卡
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} page 要写入的页地址, 范围: 0 ~ 2047
|
* @param {number} offset 要写入的页内起始地址, 范围: 0 ~ 263
|
* @param {string} data 要写入的数据.
|
*/
|
reader.at45d041Write = function(icdev, page, offset, data) {
|
SendCmd([READER_CMD._reader_cmd_45D041_write, icdev, page, offset, data]);
|
};
|
|
/**
|
* 读 AT45D041 卡
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} page 要读取的页地址, 范围: 0 ~ 2047
|
* @param {number} offset 要读取的页内起始地址, 范围: 0 ~ 263
|
* @param {number} len 要读取的数据的字节长度, 范围: 1 ~ 264
|
* @returns {string} 读取到的数据, 长度为 len * 2.
|
*/
|
reader.at45d041Read = function(icdev, offset, page, len) {
|
SendCmd([READER_CMD._reader_cmd_45D041_read, icdev, page, offset, len]);
|
};
|
|
/************ SLE4442 卡操作 ***************************************************************/
|
/**
|
* 读 SLE4442 卡
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} offset 读取数据的起始地址. 范围: 0 ~ 255.
|
* @param {number} len 读取数据的字节长度, 范围: 1 ~ 256.
|
* @returns {string} 读取到的数据, 长度为 len * 2.
|
*/
|
reader.sle4442Read = function(icdev, offset, len) {
|
SendCmd([READER_CMD._reader_cmd_4442_read, icdev, offset, len]);
|
};
|
|
/**
|
* 写 SLE4442 卡
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} offset 写入数据的起始地址. 范围: 0 ~ 255.
|
* @param {string} data 要写入的数据.
|
*/
|
reader.sle4442Write = function(icdev, offset, data) {
|
SendCmd([READER_CMD._reader_cmd_4442_write, icdev, offset, data]);
|
};
|
|
/**
|
* 验证 SLE4442 卡密码, 密码校验成功后才能对卡片中的数据进行修改.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} sc 卡密码, 长度为 6.
|
*/
|
reader.sle4442VerifySC = function(icdev, sc) {
|
SendCmd([READER_CMD._reader_cmd_4442_verify_sc, icdev, sc]);
|
};
|
|
/**
|
* 更改 SLE4442 卡密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} sc 新密码, 长度为 6.
|
*/
|
reader.sle4442ChangeSC = function(icdev, sc) {
|
SendCmd([READER_CMD._reader_cmd_4442_change_sc, icdev, sc]);
|
};
|
|
/**
|
* 读 SLE4442 卡密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 读取到的卡密码. 密码校验成功后才能读取. 密码在没有校验成功之前此函数可能依然返回正确, 但实际未读取到卡片密码.
|
*/
|
reader.sle4442ReadSC = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_4442_read_sc, icdev]);
|
};
|
|
/**
|
* 读取 SLE4442 卡的密码错误计数器的值. 密码错误计数器的初始值为 3, 密码核对出错 1 次, 便减 1, 若计数器值为 0, 则卡自动锁死, 数据只可读出,
|
* 不可再进行更改也无法再进行密码核对; 若不为零时, 其中核对正确 1 次, 可恢复到初始值 3.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {number} 读取到的密码错误计数器的值
|
*/
|
reader.sle4442ReadCounter = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_4442_read_counter, icdev]);
|
};
|
|
/**
|
* 读取 SLE4442 卡的保护位
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 读取到的保护位数据, 长度为 8. SLE4442 卡字节地址 0 ～ 31 为保护区, 共 32 个字节, 每个字节用 1 bit 的保护位来标志是否被置保护.
|
* 保护位为 4 byte 共 32 bit, 对应卡片前 32 字节. 如果此 bit 为 0 表示对应的字节已置保护, 为 1 表示未置保护.
|
*/
|
reader.sle4442ReadProBit = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_4442_read_pro_bit, icdev]);
|
};
|
|
/**
|
* 保护 SLE4442 卡的保护区指定地址的数据, 保护后的数据被固化, 无法更改.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} offset 要保护的数据的起始地址. 范围: 0 ~ 23.
|
* @param {data} data 要保护的数据, 必须和卡中已存在的数据一致.
|
*/
|
reader.sle4442Protect = function(icdev, offset, data) {
|
SendCmd([READER_CMD._reader_cmd_4442_protect, icdev, offset, data]);
|
};
|
|
/************ SLE4428 卡操作 ***************************************************************/
|
|
/**
|
* 读 SLE4428 卡
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} offset 读取数据的起始地址. 范围: 0 ~ 1023.
|
* @param {number} len 读取的数据的字节长度. 范围: 1 ~ 1024.
|
* @returns {string} 读取到的数据, 长度为 len * 2.
|
*/
|
reader.sle4428Read = function(icdev, offset, len) {
|
SendCmd([READER_CMD._reader_cmd_4428_read, offset, len]);
|
};
|
|
/**
|
* 写 SLE4428 卡
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} offset 写入数据的起始地址. 范围: 0 ~ 1023.
|
* @param {string} data 要写入的数据
|
*/
|
reader.sle4428Write = function(icdev, offset, data) {
|
SendCmd([READER_CMD._reader_cmd_4428_write, offset, data]);
|
};
|
|
/**
|
* 验证 SLE4428 卡密码, 密码校验成功后才能对卡片中的数据进行修改.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} sc 卡片密码, 长度 4.
|
*/
|
reader.sle4428VerifySC = function(icdev, sc) {
|
SendCmd([READER_CMD._reader_cmd_4428_verify_sc, icdev, sc]);
|
};
|
|
/**
|
* 更改 SLE4428 卡密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} sc 新的卡片密码, 长度 4.
|
*/
|
reader.sle4428ChangeSC = function(icdev, sc) {
|
SendCmd([READER_CMD._reader_cmd_4428_change_sc, icdev, sc]);
|
};
|
|
/**
|
* 读取 SLE4428 卡密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 读取到的卡片密码, 长度 4.
|
*/
|
reader.sle4428ReadSC = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_4428_read_sc, icdev]);
|
};
|
|
/**
|
* 读取 SLE4428 卡密码错误计数器. 密码错误计数器的初始值为8, 密码核对出错 1 次, 便减 1, 若计数器值为 0, 则卡自动锁死,
|
* 数据只可读出, 不可再进行更改也无法再进行密码核对; 若不为零时, 其中核对正确 1 次, 可恢复到初始值 8.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {number} 读取到的卡片密码错误计数器的值
|
*/
|
reader.sle4428ReadCounter = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_4428_read_counter, icdev]);
|
};
|
|
/**
|
* 从 SLE4428 卡指定地址带保护位读数据.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} offset 读取数据的起始地址. 范围: 0 ~ 1023.
|
* @param {number} len 读取的数据的字节长度. 范围: 1 ~ 1024.
|
* @returns {string} 读取到的数据, 长度为 len * 4. 每两位数据为 1 个字节, 每个字节的数据后面跟一个保护位标志字节, 该字节值为 0x00 表示相应的字节已保护, 0xff 表示未被保护.
|
* @example 从 0 字节开始读取 2 个字节的数据, 返回的数据为 '010002FF', 其中 01 为 0 字节的数据, 已保护, 02 为 1 字节数据, 未保护.
|
*/
|
reader.sle4428ReadWithPro = function(icdev, offset, len) {
|
SendCmd([READER_CMD._reader_cmd_4428_read_pro, icdev, offset, len]);
|
};
|
|
/**
|
* 向 SLE4428 卡指定地址写数据并保护,保护后的数据被固化,无法更改.
|
* @param {number} icdev
|
* @param {number} offset 写入数据的起始地址. 范围: 0 ~ 1023.
|
* @param {string} data 要写入并保护的数据.
|
*/
|
reader.sle4428WritePro = function(icdev, offset, data) {
|
SendCmd([READER_CMD._reader_cmd_4428_write_pro, icdev, offset, data]);
|
};
|
|
/**
|
* 保护 SLE4428 卡的指定地址的数据, 保护后的数据被固化, 无法更改.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} offset 要保护的数据的起始地址. 范围: 0 ~ 1023.
|
* @param {data} data 要保护的数据, 必须和卡中已存在的数据一致.
|
*/
|
reader.sle4428Portect = function(icdev, offset, data) {
|
SendCmd([READER_CMD._reader_cmd_4428_protect, icdev, offset, data]);
|
};
|
|
/********** AT88SC102 卡操作 ****************************************************************/
|
/**
|
* 读取 AT88SC102 卡中的数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要读取的区地址. 0 -- 配置区; 1 -- 应用区一; 2 -- 应用区二
|
* @param {number} offset 要读取的区内偏移地址.
|
* 当 zone = 0 时取值范围为 0 ~ 21; 其中包含厂商代码, 发行商代码, 用户密码, 密码错误计数器及代码保护区数据.
|
* 当 zone = 1 时取值范围为 0 ~ 69; 其中包含应用区一读写属性, 应用区一数据及应用区一擦除密码.
|
* 当 zone = 2 时取值范围为 0 ~ 85; 其中包含应用区二读写属性, 应用区二数据, 应用区二擦除密码, 应用区二擦除密码错误计数器及测试区.
|
* @param {number} len 读取数据的字节长度.
|
* 当 zone = 0 时取值范围为 1 ~ 22; 当 zone = 1 时取值范围为 1 ~ 70; 当 zone = 2 时取值范围为 1 ~ 86;
|
* @returns {string} 读取到的数据, 长度为 len * 2.
|
*/
|
reader.at88sc102Read = function(icdev, zone, offset, len) {
|
SendCmd([READER_CMD._reader_cmd_102_read, icdev, zone, offset, len]);
|
};
|
|
/**
|
* 向 AT88SC102 卡中写入数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要写入的区地址. 0 -- 配置区; 1 -- 应用区一; 2 -- 应用区二
|
* @param {number} offset 要写入的区内偏移地址.
|
* 当 zone = 0 时取值范围为 0 ~ 21; 其中包含厂商代码, 发行商代码, 用户密码, 密码错误计数器及代码保护区数据.
|
* 当 zone = 1 时取值范围为 0 ~ 69; 其中包含应用区一读写属性, 应用区一数据及应用区一擦除密码.
|
* 当 zone = 2 时取值范围为 0 ~ 85; 其中包含应用区二读写属性, 应用区二数据, 应用区二擦除密码, 应用区二擦除密码错误计数器及测试区.
|
* @param {string} data 要写入的数据
|
*/
|
reader.at88sc102Write = function(icdev, zone, offset, data) {
|
SendCmd([READER_CMD._reader_cmd_102_write, icdev, zone, offset, data]);
|
};
|
|
/**
|
* 擦除 AT88SC102 卡指定地址的数据. 写数据之前必须先擦除数据.
|
* AT88SC102 卡擦除操作具有从偶地址开始双字节擦除特性, 即擦除一个字节时, 与之相邻的某个字节一起被擦除, 被擦两个字节的第一个字节地址必为偶数.
|
* 比如擦除地址为 35 的字节内容时, 34、35 两字节内容一起被擦除.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要擦除的区地址. 0 -- 配置区; 1 -- 应用区一; 2 -- 应用区二
|
* @param {number} offset 要擦除的区内偏移地址.
|
* 当 zone = 0 时取值范围为 0 ~ 21; 其中包含厂商代码, 发行商代码, 用户密码, 密码错误计数器及代码保护区数据.
|
* 当 zone = 1 时取值范围为 0 ~ 69; 其中包含应用区一读写属性, 应用区一数据及应用区一擦除密码.
|
* 当 zone = 2 时取值范围为 0 ~ 85; 其中包含应用区二读写属性, 应用区二数据, 应用区二擦除密码, 应用区二擦除密码错误计数器及测试区.
|
* @param {number} len 擦除的字节长度.
|
* 当 zone = 0 时取值范围为 1 ~ 22; 当 zone = 1 时取值范围为 1 ~ 70; 当 zone = 2 时取值范围为 1 ~ 86;
|
*/
|
reader.at88sc102Erase = function(icdev, zone, offset, len) {
|
SendCmd([READER_CMD._reader_cmd_102_erase, icdev, zone, offset, len]);
|
};
|
|
/**
|
* 校验 AT88SC102 卡的用户密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} sc 要校验的密码. 长度为 4.
|
*/
|
reader.at88sc102VerifySC = function(icdev, sc) {
|
SendCmd([READER_CMD._reader_cmd_102_verify_sc, icdev, sc]);
|
};
|
|
/**
|
* 更改 AT88SC102 卡的用户密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} sc 新的用户密码. 长度为 4.
|
*/
|
reader.at88sc102VerifySC = function(icdev, sc) {
|
SendCmd([READER_CMD._reader_cmd_102_change_sc, icdev, sc]);
|
};
|
|
/**
|
* 读取 AT88SC102 卡的用户密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 读取到的用户密码. 长度为 4.
|
*/
|
reader.at88sc102ReadSC = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_102_read_sc, icdev]);
|
};
|
|
/**
|
* 读取 AT88SC102 卡密码错误计数器的值. 初始值为4.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {number} 读取到的用户密码错误计数器的值.
|
*/
|
reader.at88sc102ReadCounter = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_102_read_sc_counter, icdev]);
|
};
|
|
/**
|
* 校验 AT88SC102 卡应用区擦除密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 应用区地址, 其值为 1 或 2.
|
* @param {string} ek 擦除密码, 当 zone = 1 时, ek 的长度为 12, 当 zone = 2 时, ek 的长度为 8
|
*/
|
reader.at88sc102VerifyEraseKey = function(icdev, zone, ek) {
|
SendCmd([READER_CMD._reader_cmd_102_verify_erase_key, icdev, zone, ek]);
|
};
|
|
/**
|
* 更改 AT88SC102 卡应用区擦除密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 应用区地址, 其值为 1 或 2.
|
* @param {string} ek 新的擦除密码, 当 zone = 1 时, ek 的长度为 12, 当 zone = 2 时, ek 的长度为 8
|
*/
|
reader.at88sc102ChangeEraseKey = function(icdev, zone, ek) {
|
SendCmd([READER_CMD._reader_cmd_102_change_erase_key, icdev, zone, ek]);
|
};
|
|
/**
|
* 读取 AT88SC102 卡应用区擦除密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 应用区地址, 其值为 1 或 2.
|
* @returns {string} 读取到的的擦除密码, 当 zone = 1 时, ek 的长度为 12, 当 zone = 2 时, ek 的长度为 8
|
*/
|
reader.at88sc102ReadEraseKey = function(icdev, zone) {
|
SendCmd([READER_CMD._reader_cmd_102_read_erase_key, icdev, zone]);
|
};
|
|
/**
|
* 读取 AT88SC102 卡应用 2 区擦除计数器的值. 熔断前不起作用; 熔断后应用区二擦除数限制在 128 次, 每擦除1次, 则计数器减1, 共可擦128次
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {number} 读取到的擦除计数器的值.
|
*/
|
reader.at88sc102ReadEraseCounter = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_102_read_erase_counter, icdev]);
|
};
|
|
/**
|
* AT88SC102 卡读写属性控制位清零.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要清零的应用区地址, 其值为 1 或 2.
|
* @param {number} wr 要清零的读写属性, 1 -- 写属性PR; 2 -- 读属性RD.
|
* @description 写属性控制位 PR 的作用在于控制应用区的写数据操作. 熔断前, 不论 PR 取值, 用户密码核对正确后, 可向受控应用区中写入数据.
|
* 熔断后, 当 PR 设置为 1 时 用户密码核对正确后, 可写入数据; 当 PR 设置为 0 时, 任何情况下不可写.
|
* 读属性控制位 RD 的作用在于控制应用区的读数据操作. 熔断前后属性一致
|
* 当 RD 设置为 1 时, 任何情况下可读出受控应用区的数据; 当 RD 置为 0 时, 用户密码核对正确后, 方可读出数据
|
*/
|
reader.at88sc102PrRdClear = function(icdev, zone, wr) {
|
SendCmd([READER_CMD._reader_cmd_102_PR_RD_clear, icdev, zone, wr]);
|
};
|
|
/**
|
* AT88SC102 卡模拟个人化操作
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} mode 0 -- 模拟个人化操作; 1 -- 取消模拟.
|
*/
|
reader.at88sc102SimulatePsnl = function(icdev, mode) {
|
SendCmd([READER_CMD._reader_cmd_102_simulate_psnl, icdev, mode]);
|
};
|
|
/**
|
* AT88SC102 卡个人化(熔断)操作, 不可逆
|
* @param {number} icdev 连接读写器返回的句柄
|
*/
|
reader.at88sc102Psnl = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_102_psnl, icdev]);
|
};
|
|
/************ AT88SC1604 卡操作 **************************************************************/
|
/**
|
* 读 AT88SC1604 卡中的数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要读取的区地址; 0 -- 公共区; 1 ~ 4 为应用区
|
* @param {number} offset 要读取数据的起始地址
|
* 当 zone = 0 时取值范围: 0 ~ 26; 其中包含厂商代码, 发行商代码, 总密码, 总密码错误计数器, 代码保护区, 应用一区密码, 一区密码错误计数器, 一区擦除密码及一区擦除密码错误计数器
|
* 当 zone = 1 时取值范围: 0 ~ 1199; 其中包含应用一区数据(前 1195 byte), 二区密码, 二区擦除密码及二区擦除密码错误计数器.
|
* 当 zone = 2 时取值范围: 0 ~ 260; 其中包含应用二区数据(前 256 byte), 三区密码, 三区擦除密码及三区擦除密码错误计数器.
|
* 当 zone = 3 时取值范围: 0 ~ 260; 其中包含应用三区数据(前 256 byte), 四区密码, 四区擦除密码及四区擦除密码错误计数器.
|
* 当 zone = 4 时取值范围: 0 ~ 257; 其中包含应用四区数据(前 256 byte)及测试区.
|
* @param {number} len 要读取的字节长度.
|
* 当 zone = 0 时取值范围: 1 ~ 27; 当 zone = 1 时取值范围: 1 ~ 1200; 当 zone = 2 时取值范围: 1 ~ 261; 当 zone = 3 时取值范围: 1 ~ 261; 当 zone = 4 时取值范围: 1 ~ 258;
|
* @returns {string} 读取到的数据, 长度为 len * 2.
|
*/
|
reader.at88sc1604Read = function(icdev, zone, offset, len) {
|
SendCmd([READER_CMD._reader_cmd_1604_read, icdev, zone, offset, len]);
|
};
|
|
/**
|
* 向 AT88SC1604 卡中指定地址写入数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要写入的区地址; 0 -- 公共区; 1 ~ 4 为应用区
|
* @param {number} offset 要写入数据的起始地址
|
* 当 zone = 0 时取值范围: 0 ~ 26; 其中包含厂商代码, 发行商代码, 总密码, 总密码错误计数器, 代码保护区, 应用一区密码, 一区密码错误计数器, 一区擦除密码及一区擦除密码错误计数器
|
* 当 zone = 1 时取值范围: 0 ~ 1199; 其中包含应用一区数据(前 1195 byte), 二区密码, 二区擦除密码及二区擦除密码错误计数器.
|
* 当 zone = 2 时取值范围: 0 ~ 260; 其中包含应用二区数据(前 256 byte), 三区密码, 三区擦除密码及三区擦除密码错误计数器.
|
* 当 zone = 3 时取值范围: 0 ~ 260; 其中包含应用三区数据(前 256 byte), 四区密码, 四区擦除密码及四区擦除密码错误计数器.
|
* 当 zone = 4 时取值范围: 0 ~ 257; 其中包含应用四区数据(前 256 byte)及测试区.
|
* @param {string} data 要写入的数据
|
*/
|
reader.at88sc1604Write = function(icdev, zone, offset, data) {
|
SendCmd([READER_CMD._reader_cmd_1604_write, icdev, zone, offset, data]);
|
};
|
|
/**
|
* 擦除 AT88SC1604 卡中的数据, 写数据之前必须先擦除数据.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要擦除数据的区地址; 0 -- 公共区; 1 ~ 4 为应用区
|
* @param {number} offset 要擦除数据的起始地址
|
* 当 zone = 0 时取值范围: 0 ~ 26; 其中包含厂商代码, 发行商代码, 总密码, 总密码错误计数器, 代码保护区, 应用一区密码, 一区密码错误计数器, 一区擦除密码及一区擦除密码错误计数器
|
* 当 zone = 1 时取值范围: 0 ~ 1199; 其中包含应用一区数据(前 1195 byte), 二区密码, 二区擦除密码及二区擦除密码错误计数器.
|
* 当 zone = 2 时取值范围: 0 ~ 260; 其中包含应用二区数据(前 256 byte), 三区密码, 三区擦除密码及三区擦除密码错误计数器.
|
* 当 zone = 3 时取值范围: 0 ~ 260; 其中包含应用三区数据(前 256 byte), 四区密码, 四区擦除密码及四区擦除密码错误计数器.
|
* 当 zone = 4 时取值范围: 0 ~ 257; 其中包含应用四区数据(前 256 byte)及测试区.
|
* @param {number} len 要擦除的字节长度.
|
* 当 zone = 0 时取值范围: 1 ~ 27; 当 zone = 1 时取值范围: 1 ~ 1200; 当 zone = 2 时取值范围: 1 ~ 261; 当 zone = 3 时取值范围: 1 ~ 261; 当 zone = 4 时取值范围: 1 ~ 258;
|
*/
|
reader.at88sc1604Erase = function(icdev, zone, offset, len) {
|
SendCmd([READER_CMD._reader_cmd_1604_erase, icdev, zone, offset, len]);
|
};
|
|
/**
|
* 校验 AT88SC1604 卡密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要校验的密码区域, 0 -- 主密码; 1 ~ 4 为应用区密码.
|
* @param {string} sc 密码, 长度为 4.
|
*/
|
reader.at88sc1604VerifySC = function(icdev, zone, sc) {
|
SendCmd([READER_CMD._reader_cmd_1604_verify_sc, icdev, zone, sc]);
|
};
|
|
/**
|
* 更改 AT88SC1604 卡密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要更改的密码区域, 0 -- 主密码; 1 ~ 4 为应用区密码.
|
* @param {string} sc 新密码, 长度为 4.
|
*/
|
reader.at88sc1604ChangeSC = function(icdev, zone, sc) {
|
SendCmd([READER_CMD._reader_cmd_1604_change_sc, icdev, zone, sc]);
|
};
|
|
/**
|
* 读取 AT88SC1604 卡密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要读取的密码区域, 0 -- 主密码; 1 ~ 4 为应用区密码.
|
* @returns {string} 读取到的密码, 长度为 4.
|
*/
|
reader.at88sc1604ReadSC = function(icdev, zone) {
|
SendCmd([READER_CMD._reader_cmd_1604_Read_sc, icdev, zone]);
|
};
|
|
/**
|
* 读取 AT88SC1604 卡的密码错误计数器
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要读取错误计数的密码区域, 0 -- 主密码; 1 ~ 4 为应用区密码.
|
* @returns {number} 读取到的密码错误计数器的值
|
*/
|
reader.at88sc1604ReadCounter = function(icdev, zone) {
|
SendCmd([READER_CMD._reader_cmd_1604_read_sc_counter, icdev, zone]);
|
};
|
|
/**
|
* 核对 AT88SC1604 卡擦除密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要验证密码的应用区地址, 取值 1 ~ 4.
|
* @param {string} ek 要验证的擦除密码, 长度为 4.
|
*/
|
reader.at88sc1604VerifyEraseKey = function(icdev, zone, ek) {
|
SendCmd([READER_CMD._reader_cmd_1604_verify_erase_key, icdev, zone, ek]);
|
};
|
|
/**
|
* 更改 AT88SC1604 卡擦除密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要更改密码的应用区地址, 取值 1 ~ 4.
|
* @param {string} ek 新的擦除密码, 长度为 4.
|
*/
|
reader.at88sc1604ChangeEraseKey = function(icdev, zone, ek) {
|
SendCmd([READER_CMD._reader_cmd_1604_change_erase_key, icdev, zone, ek]);
|
};
|
|
/**
|
* 读取 AT88SC1604 卡擦除密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要读取密码的应用区地址, 取值 1 ~ 4.
|
* @returns {string} 读取到的擦除密码, 长度为 4.
|
*/
|
reader.at88sc1604ReadEraseKey = function(icdev, zone) {
|
SendCmd([READER_CMD._reader_cmd_1604_read_erase_key, icdev, zone]);
|
};
|
|
/**
|
* 读出 AT88SC1604 卡擦除密码错误计数器值
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要读取密码错误计数的应用区地址, 取值 1 ~ 4.
|
* @returns {number} 读取到的擦除密码错误计数
|
*/
|
reader.at88sc1604ReadEraseKeyCounter = function(icdev, zone) {
|
SendCmd([READER_CMD._reader_cmd_1604_read_erase_key_counter, icdev, zone]);
|
};
|
|
/**
|
* AT88SC1604 卡读写属性控制位清零.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要清零的应用区地址, 取值 1 ~ 4.
|
* @param {number} wr 要清零的读写属性, 1 -- 写属性PR; 2 -- 读属性RD.
|
*/
|
reader.at88sc1604PrRdClear = function(icdev, zone, wr) {
|
SendCmd([READER_CMD._reader_cmd_1604_PR_RD_clear, icdev, zone, wr]);
|
};
|
|
/**
|
* AT88SC1604 卡模拟个人化操作
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} mode 0 -- 模拟个人化操作; 1 -- 取消模拟
|
*/
|
reader.at88sc1604SimulatePsnl = function(icdev, mode) {
|
SendCmd([READER_CMD._reader_cmd_1604_simulate_psnl, icdev, mode]);
|
};
|
|
/**
|
* AT88SC1604 卡个人化(熔断)操作,不可逆
|
* @param {number} icdev 连接读写器返回的句柄
|
*/
|
reader.at88sc1604Psnl = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_1604_psnl, icdev]);
|
};
|
|
/******** AT88SC1608 卡操作 ********************************************************/
|
|
/**
|
* AT88SC1608 卡复位
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 卡片返回的复位信息, 长度为 8.
|
*/
|
reader.at88sc1608Reset = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_1608_reset, icdev]);
|
};
|
|
/**
|
* 读取 AT88SC1608 卡用户区数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 读取的用户区, 取值 0 ~ 7.
|
* @param {number} offset 读取的起始地址.范围 0 ~ 255.
|
* @param {number} len 要读取的字节长度. 范围 1 ~ 256.
|
* @returns {string} 返回读取到的数据, 长度为 len * 2.
|
*/
|
reader.at88sc1608ReadUser = function(icdev, zone, offset, len) {
|
SendCmd([READER_CMD._reader_cmd_1608_read_user, icdev, zone, offset, len]);
|
};
|
|
/**
|
* 向 AT88SC1608 卡用户区写数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 写入的用户区, 取值 0 ~ 7.
|
* @param {number} offset 写入的起始地址.范围 0 ~ 255.
|
* @param {number} data 写入的数据
|
*/
|
reader.at88sc1608WriteUser = function(icdev, zone, offset, data) {
|
SendCmd([READER_CMD._reader_cmd_1608_write_user, icdev, zone, offset, data]);
|
};
|
|
/**
|
* 读 AT88SC1608 卡配置区数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} offset 要读取的起始地址. 范围 0 ~ 127.
|
* @param {number} len 要读取的字节长度. 范围 1 ~ 128.
|
* @returns {string} 读取到的数据, 长度为 len * 2.
|
*/
|
reader.at88sc1608ReadConfig = function(icdev, offset, len) {
|
SendCmd([READER_CMD._reader_cmd_1608_read_config, icdev, offset, len]);
|
};
|
|
/**
|
* 写 AT88SC1608 卡配置区数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} offset 要写入的起始地址. 范围 0 ~ 127.
|
* @param {string} data 要写入的数据
|
*/
|
reader.at88sc1608WriteConfig = function(icdev, offset, data) {
|
SendCmd([READER_CMD._reader_cmd_1608_write_config, icdev, offset, data]);
|
};
|
|
/**
|
* 校验 AT88SC1608 卡密码. 哪个区用哪套密码或是否要认证要由访问权限 AR0 ~ AR7 来决定.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} sets 验证的密码组编号, 取值 0 ~ 7
|
* @param {number} wr 验证的密码类型, 0 -- 写密码; 1 -- 读密码.
|
* @param {string} pwd 要验证的密码, 长度为 6.
|
*/
|
reader.at88sc1608VerifyPwd = function(icdev, sets, wr, pwd) {
|
SendCmd([READER_CMD._reader_cmd_1608_verify_pwd, icdev, sets, wr, pwd]);
|
};
|
|
/**
|
* 修改 AT88SC1608 卡用户区密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} sets 修改的密码组编号, 取值 0 ~ 7
|
* @param {number} wr 修改的密码类型, 0 -- 写密码; 1 -- 读密码.
|
* @param {string} pwd 新的密码, 长度为 6.
|
*/
|
reader.at88sc1608ChangePwd = function(icdev, sets, wr, pwd) {
|
SendCmd([READER_CMD._reader_cmd_1608_change_pwd, icdev, sets, wr, pwd]);
|
};
|
|
/**
|
* 读 AT88SC1608 卡密码.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} sets 要读取的密码组编号, 取值 0 ~ 7
|
* @param {number} wr 要读取的密码类型, 0 -- 写密码; 1 -- 读密码.
|
* @returns {string} 读取到的密码, 长度为 6.
|
*/
|
reader.at88sc1608ReadPwd = function(icdev, sets, wr) {
|
SendCmd([READER_CMD._reader_cmd_1608_read_pwd, icdev, sets, wr]);
|
};
|
|
/**
|
* 读 AT88SC1608 卡密码错误计数.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} sets 要读取错误计数的密码组编号, 取值 0 ~ 7
|
* @param {number} wr 要读取错误计数的密码类型, 0 -- 写密码; 1 -- 读密码.
|
* @returns {number} 读取到的错误计数的值
|
*/
|
reader.at88sc1608ReadPwdCounter = function(icdev, sets, wr) {
|
SendCmd([READER_CMD._reader_cmd_1608_read_pwd_counter, icdev, sets, wr]);
|
};
|
|
/**
|
* 读 AT88SC1608 卡的 AR 值.(用户区访问权限寄存器)
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要读取 AR 的用户区, 取值 0 ~ 7.
|
* @returns {number} 读取到的 AR 的值
|
*/
|
reader.at88sc1608ReadAR = function(icdev, zone) {
|
SendCmd([READER_CMD._reader_cmd_1608_read_ar, icdev, zone]);
|
};
|
|
/**
|
* 更改 AT88SC1608 卡的 AR（用户区访问权限寄存器）
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要更改 AR 的用户区, 取值 0 ~ 7.
|
* @param {number} ar 新的 AR 值
|
*/
|
reader.at88sc1608WriteAR = function(icdev, zone, ar) {
|
SendCmd([READER_CMD._reader_cmd_1608_write_ar, icdev, zone, ar]);
|
};
|
|
/**
|
* 读取 AT88SC1608 卡熔断标志. 熔断标志 fuse 占一个字节, 低三位分别为 FAB, CMA, PER. 如果全为 1 表示所有的存储空间可读写, 如果为 0 表示已熔断, 不可逆.
|
* FAB 为 ATMEL 的芯片出厂时的熔断标志; CMA 为卡厂的卡片出厂时的熔断标志; PER 为应用系统启动前个人化时的熔断标志。
|
* 在将芯片运送到卡制造商之前, ATMEL 做 FAB 熔断操作, 使 FAB = 0.
|
* 在将卡运送到发卡机构之前, 卡厂写入自己的卡商代码, 做 CMA 熔断操作, 使 CMA = 0.
|
* 将卡运送给最终用户之前，发行机构会做 PER 熔断操作，使 PER = 0.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {number} 读取到的熔断标志的值
|
*/
|
reader.at88sc1608ReadFuse = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_1608_read_fuse, icdev]);
|
};
|
|
/**
|
* AT88SC1608 卡个人化操作（熔断操作, 使 PER = 0).
|
* @param {number} icdev 连接读写器返回的句柄
|
*/
|
reader.at88sc1608Psnl = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_1608_psnl, icdev]);
|
};
|
|
/************** AT88SC153 卡操作 **********************************************************/
|
/**
|
* 对AT88SC153卡复位,操作卡前需要进行复位操作.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 卡片返回的复位信息, 长度为 8.
|
*/
|
reader.at88sc153Reset = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_153_reset, icdev]);
|
};
|
|
/**
|
* 读 AT88SC153 卡用户区数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要读取数据的用户区,范围 0 ~ 2
|
* @param {number} offset 读取的起始地址, 范围 0 ~ 63.
|
* @param {number} len 要读取的字节长度, 范围 1 ~ 64.
|
* @returns {string} 读取到的数据, 长度 len * 2.
|
*/
|
reader.at88sc153ReadUser = function(icdev, zone, offset, len) {
|
SendCmd([READER_CMD._reader_cmd_153_read_user, icdev, zone, offset, len]);
|
};
|
|
/**
|
* 写 AT88SC153 卡用户区数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要写入数据的用户区,范围 0 ~ 2
|
* @param {number} offset 写入数据的起始地址, 范围 0 ~ 63.
|
* @param {string} data 要写入的数据
|
*/
|
reader.at88sc153WriteUser = function(icdev, zone, offset, data) {
|
SendCmd([READER_CMD._reader_cmd_153_write_user, icdev, zone, offset, data]);
|
};
|
|
/**
|
* 读 AT88SC153 卡配置区数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} offset 要读取的起始地址, 范围 0 ~ 63.
|
* @param {number} len 要读取的字节长度. 范围 1 ~ 64.
|
* @returns {string} 读取到的数据, 长度为 len * 2.
|
*/
|
reader.at88sc153ReadConfig = function(icdev, offset, len) {
|
SendCmd([READER_CMD._reader_cmd_153_read_config, icdev, offset, len]);
|
};
|
|
/**
|
* 写 AT88SC153 卡配置区数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} offset 写入的起始地址, 范围 0 ~ 63.
|
* @param {string} data 要写入的数据
|
*/
|
reader.at88sc153WriteConfig = function(icdev, offset, data) {
|
SendCmd([READER_CMD._reader_cmd_153_write_config, icdev, offset, data]);
|
};
|
|
/**
|
* 校验 AT88SC153 卡的读写密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} sets 要校验的密码组编号: 0 ~ 1
|
* @param {number} wr 要校验的密码类型, 0 -- write key; 1 -- read key.
|
* @param {string} pwd 密码, 长度为 6.
|
*/
|
reader.at88sc153VerifyPwd = function(icdev, sets, wr, pwd) {
|
SendCmd([READER_CMD._reader_cmd_153_verify_pwd, icdev, sets, wr, pwd]);
|
};
|
|
/**
|
* 更改 AT88SC153 卡的读写密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} sets 要更改的密码组编号: 0 ~ 1
|
* @param {number} wr 要更改的密码类型, 0 -- write key; 1 -- read key.
|
* @param {string} pwd 新密码, 长度为 6.
|
*/
|
reader.at88sc153ChangePwd = function(icdev, sets, wr, pwd) {
|
SendCmd([READER_CMD._reader_cmd_153_change_pwd, icdev, sets, wr, pwd]);
|
};
|
|
/**
|
* 读 AT88SC153 卡的读写密码
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} sets 要读取的密码组编号: 0 ~ 1
|
* @param {number} wr 要读取的密码类型, 0 -- write key; 1 -- read key.
|
* @returns {string} 读取到的密码
|
*/
|
reader.at88sc153ReadPwd = function(icdev, sets, wr) {
|
SendCmd([READER_CMD._reader_cmd_153_read_pwd, icdev, sets, wr]);
|
};
|
|
/**
|
* 读 AT88SC153 卡的读写密码错误计数器
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} sets 要读取错误计数的密码组编号: 0 ~ 1
|
* @param {number} wr 要读取错误计数的密码类型, 0 -- write key; 1 -- read key.
|
* @returns {number} 读取到的密码错误计数器的值.
|
*/
|
reader.at88sc153ReadPwdCounter = function(icdev, sets, wr) {
|
SendCmd([READER_CMD._reader_cmd_153_read_pwd_counter, icdev, sets, wr]);
|
};
|
|
/**
|
* 读 AT88SC153 卡的 AR (用户区访问权限寄存器)
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要读取 AR 的用户区: 0 ~ 2.
|
* @returns {number} 读取到的 AR 的值.
|
*/
|
reader.at88sc153ReadAR = function(icdev, zone) {
|
SendCmd([READER_CMD._reader_cmd_153_read_ar, icdev, zone]);
|
};
|
|
/**
|
* 写 AT88SC153 卡的 AR (用户区访问权限寄存器)
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} zone 要写 AR 的用户区: 0 ~ 2.
|
* @param {number} ar 要写入的 AR 的值
|
*/
|
reader.at88sc153WriteAR = function(icdev, zone, ar) {
|
SendCmd([READER_CMD._reader_cmd_153_write_ar, icdev, zone, ar]);
|
};
|
|
/**
|
* 读 AT88SC153 卡的 DCR (设备配置寄存器)
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {numer} 读取到的 DCR 的值
|
*/
|
reader.at88sc153ReadDCR = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_153_read_dcr, icdev]);
|
};
|
|
/**
|
* 写 AT88SC153 卡的 DCR (设备配置寄存器)
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} dcr 要写入的 DCR 的值.
|
*/
|
reader.at88sc153WriteDCR = function(icdev, dcr) {
|
SendCmd([READER_CMD._reader_cmd_153_write_dcr, icdev, dcr]);
|
};
|
|
/**
|
* 读 AT88SC153 卡的熔断标志, 熔断标志 fuse 占一个字节, 低三位分别为 FAB, CMA, PER. 如果全为 1 表示所有的存储空间可读写, 如果为 0 表示已熔断, 不可逆.
|
* FAB 为 ATMEL 的芯片出厂时的熔断标志; CMA 为卡厂的卡片出厂时的熔断标志; PER 为应用系统启动前个人化时的熔断标志。
|
* 在将芯片运送到卡制造商之前, ATMEL 做 FAB 熔断操作, 使 FAB = 0.
|
* 在将卡运送到发卡机构之前, 卡厂写入自己的卡商代码, 做 CMA 熔断操作, 使 CMA = 0.
|
* 将卡运送给最终用户之前，发行机构会做 PER 熔断操作，使 PER = 0.
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {number} 读取到的熔断标志的值
|
*/
|
reader.at88sc153ReadFuse = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_153_read_fuse, icdev]);
|
};
|
|
/**
|
* 写 AT88SC153 卡的熔断标志
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} fuse 要写入的熔断标志的值, FAB, CMA, PER 必须依次熔断
|
*/
|
reader.at88sc153WriteFuse = function(icdev, fuse) {
|
SendCmd([READER_CMD._reader_cmd_153_write_fuse, icdev, fuse]);
|
};
|
|
/**
|
* AT88SC153 卡个人化（熔断操作, 使 PER = 0)
|
* @param {number} icdev 连接读写器返回的句柄
|
*/
|
reader.at88sc153Psnl = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_153_psnl, icdev]);
|
};
|
|
/*********** 特殊应用卡操作 ***********************************************************************/
|
/**
|
* 读磁条卡数据
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {number} timeout 超时时间, 单位为秒. 在此时间内如果没有刷卡, 将返回超时错误
|
* @returns {string} 读取到的磁条卡 1, 2, 3 三个磁道上的数据, 分别用 # 号隔开
|
*/
|
reader.magneticStripRead = function(icdev, timeout) {
|
SendCmd([READER_CMD._reader_cmd_mag_read, icdev, timeout]);
|
};
|
|
/**
|
* 读取身份证信息
|
* @param {number} icdev 连接读写器返回的句柄
|
* @param {string} imgPath 身份证图片存放绝对路径, 包含文件名, 后缀.bmp, 如"D:\id.bmp"
|
* @returns {string} 读取到的信息, 分别为姓名, 性别, 名族, 出生日期, 身份证号, 地址, 发证机关及有效期, 用 # 号隔开
|
*/
|
reader.identityRead = function(icdev, imgPath) {
|
SendCmd([READER_CMD._reader_cmd_identity_read, icdev, imgPath]);
|
};
|
|
/**
|
* 读社保卡基本信息
|
* @param {number}} icdev 连接读写器返回的句柄
|
* @returns {string} 读取到的信息, 分别为社保卡号, 姓名, 性别, 名族, 身份证号及出生日期, 用 # 号隔开
|
*/
|
reader.socialSecurityReadInfo = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_ssc_read, icdev]);
|
};
|
|
/**
|
* 读健康卡号
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 读取到的健康卡号
|
*/
|
reader.healthReadNumber = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_hc_read, icdev]);
|
};
|
|
/**
|
* 读银行卡/信用卡号
|
* @param {number} icdev 连接读写器返回的句柄
|
* @returns {string} 读取到的读银行卡或信用卡号
|
*/
|
reader.bankReadNumber = function(icdev) {
|
SendCmd([READER_CMD._reader_cmd_bc_read, icdev]);
|
};
|
|
return reader;
|
}
|
|
//https://www.jianshu.com/p/5507b3a85cc5
|
function EventTarget() {
|
// 消息容器，用来存放消息和要对应的操作函数
|
this.handlers = {};
|
}
|
|
EventTarget.prototype = {
|
constructor: EventTarget,
|
// 添加注册消息接口
|
addEvent: function(type, func) {
|
// 当消息不存在时，创建一个该消息类型，将回调函数推入执行队列中
|
if (typeof this.handlers[type] === 'undefined') {
|
this.handlers[type] = [func];
|
} else {
|
// 消息类型存在时，将回调函数推入执行队列中
|
this.handlers[type].push(func);
|
}
|
},
|
// 发布消息接口
|
fireEvent: function(type, event) {
|
// 当消息不存在时直接返回
|
if (!this.handlers[type])
|
return;
|
|
if (!event.target) {
|
event.target = this;
|
}
|
|
// 依次执行消息对应的动作队列
|
for (var i = 0, len = this.handlers[type].length; i < len; i++) {
|
this.handlers[type][i].call(this, event)
|
}
|
},
|
// 移除消息接口
|
removeEvent: function(type, handler) {
|
if (this.handlers[type] instanceof Array) {
|
var handlers = this.handlers[type];
|
// 开始遍历，如果存在该动作则将其移除
|
for (var i = 0; i < handlers.length; i++) {
|
if (handlers[i] === handler) {
|
break;
|
}
|
}
|
handlers.splice(i, 1);
|
}
|
}
|
};
|
