SEGAy/Arduino-Aime-Reader
1
0
Fork 0
mirror of synced 2024-11-23 23:50:56 +01:00
Code Releases Activity

添加 PN532_FeliCa_THROUGH 选项，修改读写数据结构体，更新文档

Browse Source
This commit is contained in:
Sucareto 2024-11-05 17:30:04 +08:00
parent 03cd07ae73
commit 1617b07317
3 changed files with 157 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

187
Aime_Reader.h
View File

@ -59,9 +59,9 @@ PN532 nfc(pn532);
#define NUM_LEDS 8 #define NUM_LEDS 8
CRGB leds[NUM_LEDS]; CRGB leds[NUM_LEDS];
uint8_t KeyA[6], KeyB[6]; // 用于存储 MIFARE key uint8_t KeyA[6], KeyB[6]; // 用于存储 MIFARE key
enum { // 命令标记 enum { // 命令标记
CMD_GET_FW_VERSION = 0x30, CMD_GET_FW_VERSION = 0x30,
CMD_GET_HW_VERSION = 0x32, CMD_GET_HW_VERSION = 0x32,
// Card read // Card read
@ -81,9 +81,8 @@ enum { // 命令标记
CMD_TO_UPDATER_MODE = 0x60, CMD_TO_UPDATER_MODE = 0x60,
CMD_SEND_HEX_DATA = 0x61, CMD_SEND_HEX_DATA = 0x61,
CMD_TO_NORMAL_MODE = 0x62, CMD_TO_NORMAL_MODE = 0x62,
CMD_FIRMWARE_UPDATE = 0x64, CMD_SEND_BINDATA_INIT = 0x63,
// CMD_SEND_BINDATA_INIT = 0x63, CMD_SEND_BINDATA_EXEC = 0x64,
// CMD_SEND_BINDATA_EXEC = 0x64,
// FeliCa // FeliCa
// CMD_FELICA_PUSH = 0x70, // CMD_FELICA_PUSH = 0x70,
CMD_FELICA_THROUGH = 0x71, CMD_FELICA_THROUGH = 0x71,
@ -98,7 +97,8 @@ enum { // 命令标记
CMD_EXT_TO_NORMAL_MODE = 0xf5, CMD_EXT_TO_NORMAL_MODE = 0xf5,
}; };
enum { // FeliCa 专用，在 CMD_FELICA_THROUGH 命令使用 #ifndef PN532_FeliCa_THROUGH
enum { // FeliCa 专用，在 CMD_FELICA_THROUGH 命令使用
FelicaPolling = 0x00, FelicaPolling = 0x00,
FelicaReqResponce = 0x04, FelicaReqResponce = 0x04,
FelicaReadWithoutEncryptData = 0x06, FelicaReadWithoutEncryptData = 0x06,
@ -106,8 +106,9 @@ enum { // FeliCa 专用，在 CMD_FELICA_THROUGH 命令使用
FelicaReqSysCode = 0x0C, FelicaReqSysCode = 0x0C,
FelicaActive2 = 0xA4, FelicaActive2 = 0xA4,
}; };
#endif
enum { // 命令执行状态，res 数据包专用 enum { // 命令执行状态，res 数据包专用
STATUS_OK = 0x00, STATUS_OK = 0x00,
STATUS_CARD_ERROR = 0x01, STATUS_CARD_ERROR = 0x01,
STATUS_NOT_ACCEPT = 0x02, STATUS_NOT_ACCEPT = 0x02,
@ -117,18 +118,18 @@ enum { // 命令执行状态，res 数据包专用
STATUS_INTERNAL_ERROR = 0x06, STATUS_INTERNAL_ERROR = 0x06,
STATUS_INVALID_FIRM_DATA = 0x07, STATUS_INVALID_FIRM_DATA = 0x07,
STATUS_FIRM_UPDATE_SUCCESS = 0x08, STATUS_FIRM_UPDATE_SUCCESS = 0x08,
STATUS_COMP_DUMMY_2ND = 0x10, STATUS_COMP_DUMMY_2ND = 0x10, // 837-15286
STATUS_COMP_DUMMY_3RD = 0x20, STATUS_COMP_DUMMY_3RD = 0x20, // 837-15396
}; };
typedef union { // 大小为 128 bytes 的联合体，用于存储收到的请求命令数据 typedef union { // 大小为 128 bytes 的联合体，用于存储收到的请求命令数据
uint8_t bytes[128]; uint8_t bytes[128];
struct { struct {
uint8_t frame_len; // 数据包长度，不包含转义符 uint8_t frame_len; // 数据包长度，不包含转义符
uint8_t addr; uint8_t addr;
uint8_t seq_no; // 数据包序号 uint8_t seq_no; // 数据包序号
uint8_t cmd; // 命令标记 uint8_t cmd; // 命令标记
uint8_t payload_len; // 后续数据长度 uint8_t payload_len; // 后续数据长度
union { union {
uint8_t key[6]; // CMD_MIFARE_KEY_SET uint8_t key[6]; // CMD_MIFARE_KEY_SET
uint8_t color_payload[3]; // CMD_EXT_BOARD_LED_RGB uint8_t color_payload[3]; // CMD_EXT_BOARD_LED_RGB
@ -138,6 +139,9 @@ typedef union { // 大小为 128 bytes 的联合体，用于存储收到的请
}; };
struct { // CMD_FELICA_THROUGH struct { // CMD_FELICA_THROUGH
uint8_t encap_IDm[8]; uint8_t encap_IDm[8];
#ifdef PN532_FeliCa_THROUGH
uint8_t felica_through_payload[1]; // 转发给 PN532 的命令，长度可变
#else
uint8_t encap_len; uint8_t encap_len;
uint8_t encap_code; uint8_t encap_code;
union { union {
@ -156,20 +160,21 @@ typedef union { // 大小为 128 bytes 的联合体，用于存储收到的请
}; };
uint8_t felica_payload[1]; uint8_t felica_payload[1];
}; };
#endif
}; };
}; };
}; };
} packet_request_t; } packet_request_t;
typedef union {// 大小为 128 bytes 的联合体，用于存储读卡器准备回复的数据 typedef union { // 大小为 128 bytes 的联合体，用于存储读卡器准备回复的数据
uint8_t bytes[128]; uint8_t bytes[128];
struct { struct {
uint8_t frame_len; // 数据包长度，不包含转义符 uint8_t frame_len; // 数据包长度，不包含转义符
uint8_t addr; uint8_t addr;
uint8_t seq_no; // 数据包序号，需要和请求包对应 uint8_t seq_no; // 数据包序号，需要和请求包对应
uint8_t cmd;// 命令标记 uint8_t cmd; // 命令标记
uint8_t status; // 命令执行状态标记 uint8_t status; // 命令执行状态标记
uint8_t payload_len;// 后续数据长度 uint8_t payload_len; // 后续数据长度
union { union {
uint8_t version[1]; // CMD_GET_FW_VERSION,CMD_GET_HW_VERSION,CMD_EXT_BOARD_INFO uint8_t version[1]; // CMD_GET_FW_VERSION,CMD_GET_HW_VERSION,CMD_EXT_BOARD_INFO
uint8_t block[16]; // CMD_MIFARE_READ uint8_t block[16]; // CMD_MIFARE_READ
@ -185,6 +190,9 @@ typedef union {// 大小为 128 bytes 的联合体，用于存储读卡器准备
}; };
}; };
}; };
#ifdef PN532_FeliCa_THROUGH
uint8_t felica_through_payload[1]; // 从 PN532 收到的回复，长度可变
#else
struct { // CMD_FELICA_THROUGH struct { // CMD_FELICA_THROUGH
uint8_t encap_len; uint8_t encap_len;
uint8_t encap_code; uint8_t encap_code;
@ -202,6 +210,7 @@ typedef union {// 大小为 128 bytes 的联合体，用于存储读卡器准备
uint8_t felica_payload[1]; uint8_t felica_payload[1];
}; };
}; };
#endif
}; };
}; };
} packet_response_t; } packet_response_t;
@ -213,52 +222,52 @@ packet_response_t res;
uint8_t len, r, checksum; uint8_t len, r, checksum;
bool escape = false; bool escape = false;
uint8_t packet_read() { // 数据包读取函数 uint8_t packet_read() { // 数据包读取函数
while (SerialDevice.available()) { while (SerialDevice.available()) {
r = SerialDevice.read(); r = SerialDevice.read();
if (r == 0xE0) { // 检测到包头，重置包长度 if (r == 0xE0) { // 检测到包头，重置包长度
req.frame_len = 0xFF; req.frame_len = 0xFF;
continue; continue;
} }
if (req.frame_len == 0xFF) { // 设置包长度 if (req.frame_len == 0xFF) { // 设置包长度
req.frame_len = r; req.frame_len = r;
len = 0; len = 0;
checksum = r; checksum = r;
continue; continue;
} }
if (r == 0xD0) { // 读取到转义符，设置转义标记 if (r == 0xD0) { // 读取到转义符，设置转义标记
escape = true; escape = true;
continue; continue;
} }
if (escape) { // 转义处理 if (escape) { // 转义处理
r++; r++;
escape = false; escape = false;
} }
req.bytes[++len] = r; req.bytes[++len] = r;
if (len == req.frame_len) { // 长度正确且校验通过，则返回命令标记，否则返回 STATUS_SUM_ERROR if (len == req.frame_len) { // 长度正确且校验通过，则返回命令标记，否则返回 STATUS_SUM_ERROR
if (req.cmd == CMD_FIRMWARE_UPDATE) return CMD_FIRMWARE_UPDATE; //如果命令为0x64，则不校验checksum if (req.cmd == CMD_SEND_BINDATA_EXEC) return req.cmd; //如果命令为0x64，则不校验checksum
return checksum == r ? req.cmd : STATUS_SUM_ERROR; return checksum == r ? req.cmd : STATUS_SUM_ERROR;
} }
checksum += r; // 包头后每位数据（不含转义）相加，作为校验值 checksum += r; // 包头后每位数据（不含转义）相加，作为校验值
} }
return 0; // 数据包未读取完成 return 0; // 数据包未读取完成
} }
void packet_write() { void packet_write() {
uint8_t checksum = 0, len = 0; uint8_t checksum = 0, len = 0;
if (res.cmd == 0) { // 无待发数据 if (res.cmd == 0) { // 无待发数据
return; return;
} }
SerialDevice.write(0xE0); SerialDevice.write(0xE0);
while (len <= res.frame_len) { while (len <= res.frame_len) {
uint8_t w; uint8_t w;
if (len == res.frame_len) { // 包数据已写入完成，发送校验值 if (len == res.frame_len) { // 包数据已写入完成，发送校验值
w = checksum; w = checksum;
} else { } else {
w = res.bytes[len]; w = res.bytes[len];
checksum += w; // 包头后每位数据（不含转义）相加，作为校验值 checksum += w; // 包头后每位数据（不含转义）相加，作为校验值
} }
if (w == 0xE0 || w == 0xD0) { // 转义符写入 if (w == 0xE0 || w == 0xD0) { // 转义符写入
SerialDevice.write(0xD0); SerialDevice.write(0xD0);
SerialDevice.write(--w); SerialDevice.write(--w);
} else { } else {
@ -269,51 +278,51 @@ void packet_write() {
res.cmd = 0; res.cmd = 0;
} }
void res_init(uint8_t payload_len = 0) { // 通用回复生成，参数指定不含包头的数据长度 void res_init(uint8_t payload_len = 0) { // 通用回复生成，参数指定不含包头的数据长度
res.frame_len = 6 + payload_len; res.frame_len = 6 + payload_len;
res.addr = req.addr; res.addr = req.addr;
res.seq_no = req.seq_no; res.seq_no = req.seq_no;
res.cmd = req.cmd; res.cmd = req.cmd;
res.status = STATUS_OK; // 默认命令执行状态标记 res.status = STATUS_OK; // 默认命令执行状态标记
res.payload_len = payload_len; res.payload_len = payload_len;
} }
void sys_to_normal_mode() { // 作用未知，根据 cmd 猜测 void sys_to_normal_mode() { // 作用未知，根据 cmd 猜测
res_init(); res_init();
if (nfc.getFirmwareVersion()) { if (nfc.getFirmwareVersion()) {
res.status = STATUS_INVALID_COMMAND; // 在 837-15396 和 TN32MSEC003S 串口数据确认 res.status = STATUS_INVALID_COMMAND; // 在 837-15396 和 TN32MSEC003S 串口数据确认
} else { } else {
res.status = STATUS_INTERNAL_ERROR; res.status = STATUS_INTERNAL_ERROR;
FastLED.showColor(0xFF0000); FastLED.showColor(0xFF0000);
} }
} }
void sys_get_fw_version() { // 版本数据，通过串口数据确认，在读卡器测试界面显示 void sys_get_fw_version() { // 版本数据，通过串口数据确认，在读卡器测试界面显示
res_init(sizeof(fw_version) - 1); res_init(sizeof(fw_version) - 1);
memcpy(res.version, fw_version, res.payload_len); memcpy(res.version, fw_version, res.payload_len);
} }
void sys_get_hw_version() { // 版本数据，通过串口数据确认，在读卡器测试界面显示 void sys_get_hw_version() { // 版本数据，通过串口数据确认，在读卡器测试界面显示
res_init(sizeof(hw_version) - 1); res_init(sizeof(hw_version) - 1);
memcpy(res.version, hw_version, res.payload_len); memcpy(res.version, hw_version, res.payload_len);
} }
void sys_get_led_info() { // 版本数据，通过串口数据确认 void sys_get_led_info() { // 版本数据，通过串口数据确认
res_init(sizeof(led_info) - 1); res_init(sizeof(led_info) - 1);
memcpy(res.version, led_info, res.payload_len); memcpy(res.version, led_info, res.payload_len);
} }
void nfc_start_polling() { // 作用未知，根据 cmd 猜测，开始读卡 void nfc_start_polling() { // 作用未知，根据 cmd 猜测，开始读卡
res_init(); res_init();
nfc.setRFField(0x00, 0x01); nfc.setRFField(0x00, 0x01);
} }
void nfc_stop_polling() { // 作用未知，根据 cmd 猜测，停止读卡 void nfc_stop_polling() { // 作用未知，根据 cmd 猜测，停止读卡
res_init(); res_init();
nfc.setRFField(0x00, 0x00); nfc.setRFField(0x00, 0x00);
} }
void nfc_card_detect() { // 读取卡片类型 void nfc_card_detect() { // 读取卡片类型
uint16_t SystemCode; uint16_t SystemCode;
uint8_t bufferLength; uint8_t bufferLength;
// MIFARE // MIFARE
@ -321,7 +330,7 @@ void nfc_card_detect() { // 读取卡片类型
res_init(res.id_len + 3); res_init(res.id_len + 3);
res.count = 1; res.count = 1;
res.type = 0x10; res.type = 0x10;
// FeliCa // FeliCa
} else if (nfc.felica_Polling(0xFFFF, 0x00, res.IDm, res.PMm, &SystemCode, 200) == 1) { } else if (nfc.felica_Polling(0xFFFF, 0x00, res.IDm, res.PMm, &SystemCode, 200) == 1) {
res_init(0x13); res_init(0x13);
res.count = 1; res.count = 1;
@ -333,21 +342,21 @@ void nfc_card_detect() { // 读取卡片类型
} }
} }
void nfc_mifare_authorize_a() { // 对 MIFARE 使用 KeyA 认证 void nfc_mifare_authorize_a() { // 对 MIFARE 使用 KeyA 认证
res_init(); res_init();
if (!nfc.mifareclassic_AuthenticateBlock(req.uid, 4, req.block_no, 0, KeyA)) { if (!nfc.mifareclassic_AuthenticateBlock(req.uid, 4, req.block_no, 0, KeyA)) {
res.status = STATUS_CARD_ERROR; res.status = STATUS_CARD_ERROR;
} }
} }
void nfc_mifare_authorize_b() {// 对 MIFARE 使用 KeyB 认证 void nfc_mifare_authorize_b() { // 对 MIFARE 使用 KeyB 认证
res_init(); res_init();
if (!nfc.mifareclassic_AuthenticateBlock(req.uid, 4, req.block_no, 1, KeyB)) { if (!nfc.mifareclassic_AuthenticateBlock(req.uid, 4, req.block_no, 1, KeyB)) {
res.status = STATUS_CARD_ERROR; res.status = STATUS_CARD_ERROR;
} }
} }
void nfc_mifare_read() { // 认证成功后，读取 MIFARE 指定的 block void nfc_mifare_read() { // 认证成功后，读取 MIFARE 指定的 block
res_init(0x10); res_init(0x10);
if (!nfc.mifareclassic_ReadDataBlock(req.block_no, res.block)) { if (!nfc.mifareclassic_ReadDataBlock(req.block_no, res.block)) {
res_init(); res_init();
@ -355,17 +364,85 @@ void nfc_mifare_read() { // 认证成功后，读取 MIFARE 指定的 block
} }
} }
// 游戏发送的0x71命令后面的包实际上是完整的与Felica卡片直接通信的包，可以转发进PN532库直接用 #ifndef SKIP_FeliCa_THROUGH
// response也可以直接打包转发回游戏 void nfc_felica_through() { // FeliCa 处理函数
void nfc_felica_through() { // FeliCa 处理函数 #ifdef PN532_FeliCa_THROUGH
#pragma message "启用 PN532 FeliCa 直通"
// 游戏发送的 0x71 命令后面的包实际上是完整的与 FeliCa 卡片直接通信的包，可以转发进 PN532 库直接用
uint8_t response_length = 0xFF; uint8_t response_length = 0xFF;
if (nfc.inDataExchange(&req.encap_len, req.encap_len, &res.encap_len, &response_length)) { if (nfc.inDataExchange(req.felica_through_payload, req.felica_through_payload[0], res.felica_through_payload, &response_length)) {
res_init(response_length); res_init(response_length);
//如果成功的话 res.encap_len == response_length
} else { } else {
res_init(0); res_init();
res.status = STATUS_CARD_ERROR; res.status = STATUS_CARD_ERROR;
// 数据交换失败时返回STATUS_CARD_ERROR触发重传 // 数据交换失败时返回 STATUS_CARD_ERROR 触发重传
// 不对数据交换失败时做特殊处理，直接返回STATUS_CARD_ERROR。可能导致部分卡片（国产手机+aicemu）读取失败。 // 不对数据交换失败时做特殊处理，直接返回 STATUS_CARD_ERROR。可能导致部分卡片（国产手机 + aicemu）读取失败。
} }
#else // 旧 FeliCa 处理函数，留作参考
uint16_t SystemCode;
if (nfc.felica_Polling(0xFFFF, 0x01, res.encap_IDm, res.poll_PMm, &SystemCode, 200) == 1) {
SystemCode = SystemCode >> 8 | SystemCode << 8; // 大小端数据翻转
} else { // 如果读取 FeliCa 失败，则跳过后续操作
res_init();
res.status = STATUS_CARD_ERROR;
return;
}
uint8_t code = req.encap_code;
res.encap_code = code + 1;
switch (code) {
case FelicaPolling: // 作用未知，根据串口数据猜测
{
res_init(0x14);
res.poll_systemCode[0] = SystemCode;
res.poll_systemCode[1] = SystemCode >> 8;
}
break;
case FelicaReqSysCode: // 作用未知，根据串口数据猜测
{
res_init(0x0D);
res.felica_payload[0] = 0x01;
res.felica_payload[1] = SystemCode;
res.felica_payload[2] = SystemCode >> 8;
}
break;
case FelicaActive2: // 作用未知，根据串口数据猜测
{
res_init(0x0B);
res.felica_payload[0] = 0x00;
}
break;
case FelicaReadWithoutEncryptData:
{
uint16_t serviceCodeList = req.serviceCodeList[1] << 8 | req.serviceCodeList[0];
uint16_t blockList[4];
for (uint8_t i = 0; i < req.numBlock; i++) { // 大小端数据翻转
blockList[i] = (uint16_t)(req.blockList[i][0] << 8 | req.blockList[i][1]);
}
// 读取数据
nfc.felica_ReadWithoutEncryption(1, &serviceCodeList, req.numBlock, blockList, res.blockData);
res.RW_status[0] = 0;
res.RW_status[1] = 0;
res.numBlock = req.numBlock;
res_init(0x0D + req.numBlock * 16);
}
break;
case FelicaWriteWithoutEncryptData:
{
// 大小端数据翻转
uint16_t serviceCodeList = req.serviceCodeList[1] << 8 | req.serviceCodeList[0];
uint16_t blockList = (uint16_t)(req.blockList[0][0] << 8 | req.blockList[0][1]);
// 写入数据
nfc.felica_WriteWithoutEncryption(1, &serviceCodeList, 1, &blockList, &req.blockData);
res_init(0x0C);
res.RW_status[0] = 0;
res.RW_status[1] = 0;
}
break;
default: // 对于其他未知的数据默认处理方式，未确认效果
res_init();
res.status = STATUS_INVALID_COMMAND;
}
res.encap_len = res.payload_len;
#endif
} }
#endif

42
Arduino-Aime-Reader.ino
View File

@ -1,21 +1,21 @@
#include "Aime_Reader.h"
// 该定义存在时，使用 115200 波特率，型号为 837-15396 // 该定义存在时，使用 115200 波特率，型号为 837-15396
#define high_baudrate #define high_baudrate
// 该定义存在时，跳过实际的 FeliCa 操作 // 该定义存在时，跳过实际的 FeliCa 操作
// 仅通过 CMD_CARD_DETECT 发送 IDm、PMm、SystemCode // 仅通过 CMD_CARD_DETECT 发送 IDm、PMm、SystemCode
#define SKIP_FeliCa_THROUGH #define SKIP_FeliCa_THROUGH
// 该定义存在时，FeliCa 操作命令直接转发给 PN532
#define PN532_FeliCa_THROUGH
#include "Aime_Reader.h"
void setup() { void setup() {
FastLED.addLeds<NEOPIXEL, LED_PIN>(leds, NUM_LEDS); FastLED.addLeds<NEOPIXEL, LED_PIN>(leds, NUM_LEDS);
FastLED.setBrightness(50); FastLED.setBrightness(50);
FastLED.showColor(0); FastLED.showColor(0);
nfc.begin(); nfc.begin();
while (!nfc.getFirmwareVersion()) { // 检测不到 PN532 时，循环红灯闪烁，不再继续初始化 while (!nfc.getFirmwareVersion()) { // 检测不到 PN532 时，循环红灯闪烁，不再继续初始化
FastLED.showColor(0xFF0000); FastLED.showColor(0xFF0000);
delay(500); delay(500);
FastLED.showColor(0); FastLED.showColor(0);
@ -34,7 +34,7 @@ void setup() {
void loop() { void loop() {
// 从串口读取数据，数据校验成功后，跳转到对应的函数执行操作 // 从串口读取数据，数据校验成功后，跳转到对应的函数执行操作
switch (packet_read()) { switch (packet_read()) {
case 0: // 数据包未读取完成 case 0: // 数据包未读取完成
break; break;
case CMD_TO_NORMAL_MODE: case CMD_TO_NORMAL_MODE:
@ -59,12 +59,12 @@ void loop() {
break; break;
// MIFARE 处理 // MIFARE 处理
case CMD_MIFARE_KEY_SET_A: // 设置 MIFARE keyA case CMD_MIFARE_KEY_SET_A: // 设置 MIFARE keyA
memcpy(KeyA, req.key, 6); memcpy(KeyA, req.key, 6);
res_init(); res_init();
break; break;
case CMD_MIFARE_KEY_SET_B: // 设置 MIFARE keyB case CMD_MIFARE_KEY_SET_B: // 设置 MIFARE keyB
res_init(); res_init();
memcpy(KeyB, req.key, 6); memcpy(KeyB, req.key, 6);
break; break;
@ -81,15 +81,16 @@ void loop() {
nfc_mifare_read(); nfc_mifare_read();
break; break;
#ifndef SKIP_FeliCa_THROUGH #ifdef SKIP_FeliCa_THROUGH
// FeliCa 读写 #pragma message "跳过 FeliCa 操作"
case CMD_FELICA_THROUGH: #else
case CMD_FELICA_THROUGH: // FeliCa 读写
nfc_felica_through(); nfc_felica_through();
break; break;
#endif #endif
// LED // LED
case CMD_EXT_BOARD_LED_RGB: // 设置 LED 颜色，无需回复 case CMD_EXT_BOARD_LED_RGB: // 设置 LED 颜色，无需回复
FastLED.showColor(CRGB(req.color_payload[0], req.color_payload[1], req.color_payload[2])); FastLED.showColor(CRGB(req.color_payload[0], req.color_payload[1], req.color_payload[2]));
break; break;
@ -97,34 +98,35 @@ void loop() {
sys_get_led_info(); sys_get_led_info();
break; break;
case CMD_EXT_BOARD_LED_RGB_UNKNOWN: // 未知，仅在使用 emoney 时出现 case CMD_EXT_BOARD_LED_RGB_UNKNOWN: // 未知，仅在使用 emoney 时出现
break; break;
case CMD_CARD_SELECT: case CMD_CARD_SELECT:
case CMD_CARD_HALT: case CMD_CARD_HALT:
case CMD_EXT_TO_NORMAL_MODE: case CMD_EXT_TO_NORMAL_MODE:
case CMD_TO_UPDATER_MODE: case CMD_TO_UPDATER_MODE:
case CMD_SEND_BINDATA_INIT:
res_init(); res_init();
break; break;
case CMD_FIRMWARE_UPDATE: case CMD_SEND_BINDATA_EXEC:
res_init(); res_init();
res.status = STATUS_FIRM_UPDATE_SUCCESS; res.status = STATUS_FIRM_UPDATE_SUCCESS;
//当读卡器发送的FW版本与amdaemon要求的版本不一致时， // 当读卡器发送的 FW 版本与 amdaemon 要求的版本不一致时，
//游戏会发送0x60使读卡器进入update模式，再通过0x64再次更新， // 游戏会发送 0x60 使读卡器进入 update 模式，再通过 0x64 再次更新，
//此时需要回复0x08方可再次跳过更新 // 此时需要回复 0x08 方可再次跳过更新
break; break;
case CMD_SEND_HEX_DATA: // 非 TN32MSEC003S 时，可能会触发固件更新逻辑 case CMD_SEND_HEX_DATA: // 非 TN32MSEC003S 时，可能会触发固件更新逻辑
res_init(); res_init();
res.status = STATUS_COMP_DUMMY_3RD; res.status = STATUS_COMP_DUMMY_3RD;
// 读卡器HW版本是837-15286时应该回复0x10, 837-15396回复0x20 // 读卡器 HW 版本是 837-15286 时应该回复 0x10, 837-15396 回复 0x20
break; break;
case STATUS_SUM_ERROR: // 读取数据校验失败时的回复，未确认效果 case STATUS_SUM_ERROR: // 读取数据校验失败时的回复，未确认效果
res_init(); res_init();
res.status = STATUS_SUM_ERROR; res.status = STATUS_SUM_ERROR;
break; break;
default: // 对于其他未知的数据默认处理方式，未确认效果 default: // 对于其他未知的数据默认处理方式，未确认效果
res_init(); res_init();
res.status = STATUS_INVALID_COMMAND; res.status = STATUS_INVALID_COMMAND;
} }

6
README.md
View File

@ -49,16 +49,16 @@
### 已知问题 ### 已知问题
- 默认未启用 FeliCa 读写功能，仅在 `CMD_CARD_DETECT` 时读取 IDm 和 PMm，该设置可以通过 `SKIP_FeliCa_THROUGH` 控制 - 默认未启用 FeliCa 读写功能，仅在 `CMD_CARD_DETECT` 时读取 IDm 和 PMm，该设置可以通过 `SKIP_FeliCa_THROUGH` 控制
- 启用 FeliCa 读写功能后，默认启用 `PN532_FeliCa_THROUGH`，FeliCa 操作命令直接转发给 PN532 处理，如果需要控制读写过程，可以禁用该定义，然后修改实现函数
- 如果启用 FeliCa 读写功能，某些游戏可能不支持所有 FeliCa 卡种类，和官方读卡器行为一致 - 如果启用 FeliCa 读写功能，某些游戏可能不支持所有 FeliCa 卡种类，和官方读卡器行为一致
- 因为 PN532 库支持的问题，未实现多卡同时读取，只会读到最先识别的卡片；刷数据不正确的 MIFARE 卡片（如交通卡、模拟卡）会导致游戏状态异常 - 因为 PN532 库支持的问题，未实现多卡同时读取，只会读到最先识别的卡片；刷数据不正确的 MIFARE 卡片（如交通卡、模拟卡）会导致游戏状态异常
- 对于未适配的命令，默认回复 `STATUS_INVALID_COMMAND`，可能会导致游戏认为读卡器不可用 - 对于未适配的命令，默认回复 `STATUS_INVALID_COMMAND`，可能会导致游戏认为读卡器不可用
- [此处修改](https://github.com/Sucareto/Arduino-Aime-Reader/commit/ebb2565ce4c43e8de275790f52bebee381d0bca7#diff-abc09b3d07eff9d03039f4f22ac9ac0747790237d3d00258e38644dbf13f9bbbR103) 会影响 amdaemon 对固件更新的操作，参考[此处说明](https://github.com/Sucareto/Arduino-Aime-Reader/blob/b16c63772b6d94ad9fca2c82bd89f0e900ed03d6/Arduino-Aime-Reader.ino#L114)
### 版本更新情况 ### 版本更新情况
- [最新](https://github.com/Sucareto/Arduino-Aime-Reader/tree/main) - [最新](https://github.com/Sucareto/Arduino-Aime-Reader/tree/main)
通过 [pull/19](https://github.com/Sucareto/Arduino-Aime-Reader/pull/19) 实现了 FeliCa 的正确读写； 通过 [QHPaeek/pull/19](https://github.com/Sucareto/Arduino-Aime-Reader/pull/19) 和 [nerimoe/pull/21](https://github.com/Sucareto/Arduino-Aime-Reader/pull/21) 实现了 FeliCa 的正确读写、固件更新处理。
因未持有官方读卡器和框体等环境，无法进行更多测试，如没有 bug 或者新文档，将不会再更新。 因未持有官方读卡器和框体等环境，无法进行更多测试，如没有 bug 或者新文档，将不会再更新。
- [v2.0](https://github.com/Sucareto/Arduino-Aime-Reader/commits/v2.0) - [v2.0](https://github.com/Sucareto/Arduino-Aime-Reader/commits/v2.0)
@ -68,7 +68,7 @@
- [v1.0](https://github.com/Sucareto/Arduino-Aime-Reader/commits/v1.0) - [v1.0](https://github.com/Sucareto/Arduino-Aime-Reader/commits/v1.0)
参考 [segatools](https://github.com/djhackersdev/segatools/blob/master/board/sg-nfc-cmd.h) 编写了基本实现； 参考 [segatools](https://github.com/djhackersdev/segatools/blob/master/board/sg-nfc-cmd.h) 编写了基本实现；
分析了官方读卡器串口数据，通过猜测数据结构完善了大部分功能。 分析了官方读卡器串口数据，通过猜测数据结构完成了大部分功能。
### 参考 ### 参考