Merge pull request #6 from sysdevrun/claude/nfc-usb-reader-app-CccoR

Claude/nfc usb reader app ccco r

Author: chtitux

src/lib/nfc-device.ts

@@ -73,57 +73,94 @@ export async function sendCommand(
 }
 
 /**
- * Get card UID using RDR-518 proprietary command
+ * Get card UID using ASK RDR-518 proprietary command
  * Command: 80 0a 01 03 00 00 02 11 03 01 01 14 00 9c f8
- * Response format: [LEN] 01 03 00 [ATQA 2 bytes] 00 [SAK] [UID 4 bytes] [STATUS] [CRC-16 2 bytes]
- * Example: 0b 01 03 00 05 06 00 08 8d 69 5d f1 00 e2 4e
+ *
+ * Response format (card found - 15 bytes):
+ *   [LEN=0x0b] 01 03 00 [ATQA 2B] 00 [SAK] [UID 4B] [STATUS=0x00] [CRC-16]
+ *   Example: 0b 01 03 00 05 06 00 08 8d 69 5d f1 00 e2 4e
+ *
+ * Response format (no card - 8 bytes):
+ *   [LEN=0x04] 01 03 00 [ERROR=0x6f] 00 [CRC-16]
+ *   Example: 04 01 03 00 6f 00 1d cb
  */
 export async function getCardUid(device: NfcDevice): Promise<NfcCommandResult> {
   const command = fromHex('80 0a 01 03 00 00 02 11 03 01 01 14 00 9c f8');
   const result = await sendCommand(device, command);
 
-  if (result.success && result.data && result.data.length >= 13) {
-    // Parse RDR-518 response format
-    // [0] = LEN (0x0b = 11)
-    // [1-3] = Header (01 03 00)
-    // [4-5] = ATQA
-    // [6] = 00
-    // [7] = SAK
-    // [8-11] = UID (4 bytes)
-    // [12] = Status
-    // [13-14] = CRC-16
-
+  if (result.success && result.data && result.data.length >= 8) {
     const len = result.data[0];
-    const atqa = result.data.subarray(4, 6);
-    const sak = result.data[7];
-    const uid = result.data.subarray(8, 12);
-    const status = result.data[12];
 
-    if (status === 0x00 && len === 0x0b) {
-      return {
-        success: true,
-        data: uid,
-        hexData: toHex(uid),
-        atqa: toHex(atqa),
-        sak: sak.toString(16).padStart(2, '0').toUpperCase(),
-        message: `UID: ${toHex(uid)}`,
-      };
-    } else {
+    // Check for "no card" response: LEN=0x04, error code at [4]=0x6f
+    if (len === 0x04 && result.data.length >= 8) {
+      const errorCode = result.data[4];
+      if (errorCode === 0x6f) {
+        return {
+          success: false,
+          data: result.data,
+          hexData: result.hexData,
+          message: 'No card in field',
+        };
+      }
       return {
         success: false,
         data: result.data,
         hexData: result.hexData,
-        message: 'No card detected or read error',
+        message: `Reader error: 0x${errorCode.toString(16).padStart(2, '0')}`,
       };
     }
+
+    // Check for "card found" response: LEN=0x0b (15 bytes total)
+    if (len === 0x0b && result.data.length >= 15) {
+      // Parse card data
+      // [0] = LEN (0x0b = 11)
+      // [1-3] = Header (01 03 00)
+      // [4-5] = ATQA
+      // [6] = 00
+      // [7] = SAK
+      // [8-11] = UID (4 bytes)
+      // [12] = Status
+      // [13-14] = CRC-16
+
+      const atqa = result.data.subarray(4, 6);
+      const sak = result.data[7];
+      const uid = result.data.subarray(8, 12);
+      const status = result.data[12];
+
+      if (status === 0x00) {
+        return {
+          success: true,
+          data: uid,
+          hexData: toHex(uid),
+          atqa: toHex(atqa),
+          sak: sak.toString(16).padStart(2, '0').toUpperCase(),
+          message: `UID: ${toHex(uid)}`,
+        };
+      } else {
+        return {
+          success: false,
+          data: result.data,
+          hexData: result.hexData,
+          message: `Card error: status 0x${status.toString(16).padStart(2, '0')}`,
+        };
+      }
+    }
+
+    // Unknown response format
+    return {
+      success: false,
+      data: result.data,
+      hexData: result.hexData,
+      message: `Unknown response (LEN=0x${len.toString(16)})`,
+    };
   }
 
-  if (result.success && result.data) {
+  if (result.success && result.data && result.data.length > 0) {
     return {
       success: false,
       data: result.data,
       hexData: result.hexData,
-      message: 'No card detected',
+      message: `Incomplete response (${result.data.length} bytes)`,
     };
   }
 

src/lib/usb-cdc.ts

@@ -20,7 +20,7 @@ export interface CdcConnectionResult {
 
 // Known NFC reader USB vendor/product IDs
 export const KNOWN_NFC_READERS = [
-  { vendorId: 0x1fd3, productId: 0x0108, name: 'RDR-518 NFC Reader' },
+  { vendorId: 0x1fd3, productId: 0x0108, name: 'ASK RDR-518' },
   { vendorId: 0x072f, productId: 0x2200, name: 'ACS ACR122U' },
   { vendorId: 0x072f, productId: 0x223b, name: 'ACS ACR1252U' },
   { vendorId: 0x072f, productId: 0x8911, name: 'ACS ACR1281S-C1 (ACR518)' },

src/lib/web-serial.ts

@@ -19,7 +19,7 @@ export interface SerialConnectionResult {
 
 // Known NFC reader USB vendor/product IDs for serial filter
 export const KNOWN_SERIAL_NFC_READERS = [
-  { usbVendorId: 0x1fd3, usbProductId: 0x0108 }, // RDR-518 NFC Reader
+  { usbVendorId: 0x1fd3, usbProductId: 0x0108 }, // ASK RDR-518
   { usbVendorId: 0x072f }, // ACS readers
   { usbVendorId: 0x1a86 }, // CH340
   { usbVendorId: 0x0403 }, // FTDI
@@ -127,82 +127,135 @@ export async function sendSerialData(device: SerialDevice, data: Uint8Array): Pr
 }
 
 /**
- * Receive data from serial port with timeout
+ * Send command and receive response
+ * For ASK RDR-518: response format is [LEN] [DATA...] [CRC-16]
  */
-export async function receiveSerialData(
+export async function transceiveSerial(
   device: SerialDevice,
+  command: Uint8Array,
   timeout: number = 2000
+): Promise<Uint8Array> {
+  if (!device.reader || !device.writer) {
+    throw new Error('Serial port not ready');
+  }
+
+  // Clear any stale data in the buffer first
+  await clearSerialBuffer(device);
+
+  // Send the command
+  await sendSerialData(device, command);
+
+  // Wait for device to process command and perform RF operation
+  await new Promise(resolve => setTimeout(resolve, 150));
+
+  // Read response, looking for a complete frame
+  return await receiveSerialFrame(device, timeout);
+}
+
+/**
+ * Clear any stale data from the serial buffer
+ */
+async function clearSerialBuffer(device: SerialDevice): Promise<void> {
+  if (!device.reader) return;
+
+  const startTime = Date.now();
+  while (Date.now() - startTime < 100) {
+    try {
+      const readPromise = device.reader.read();
+      const timeoutPromise = new Promise<{ value: undefined; done: true }>((resolve) =>
+        setTimeout(() => resolve({ value: undefined, done: true }), 20)
+      );
+      const result = await Promise.race([readPromise, timeoutPromise]);
+      if (result.done || !result.value || result.value.length === 0) {
+        break; // Buffer is empty
+      }
+      // Discard stale data and continue clearing
+    } catch {
+      break;
+    }
+  }
+}
+
+/**
+ * Receive a complete frame from serial port
+ * Frame format: [LEN] [DATA...] [CRC-16]
+ * LEN=0x04 for no-card (8 bytes total), LEN=0x0b for card-found (15 bytes total)
+ */
+async function receiveSerialFrame(
+  device: SerialDevice,
+  timeout: number
 ): Promise<Uint8Array> {
   if (!device.reader) {
     throw new Error('Serial port reader not available');
   }
 
   const chunks: Uint8Array[] = [];
   const startTime = Date.now();
+  let totalBytes = 0;
 
-  try {
-    while (Date.now() - startTime < timeout) {
-      const readPromise = device.reader.read();
-      const timeoutPromise = new Promise<{ value: undefined; done: true }>((resolve) =>
-        setTimeout(() => resolve({ value: undefined, done: true }), Math.max(100, timeout - (Date.now() - startTime)))
-      );
+  while (Date.now() - startTime < timeout) {
+    const remainingTime = Math.max(50, timeout - (Date.now() - startTime));
 
-      const result = await Promise.race([readPromise, timeoutPromise]);
+    const readPromise = device.reader.read();
+    const timeoutPromise = new Promise<{ value: undefined; done: true }>((resolve) =>
+      setTimeout(() => resolve({ value: undefined, done: true }), Math.min(300, remainingTime))
+    );
 
-      if (result.done) {
-        break;
-      }
+    const result = await Promise.race([readPromise, timeoutPromise]);
 
-      if (result.value && result.value.length > 0) {
-        chunks.push(result.value);
-        // If we received data, wait a bit more for additional data
+    if (result.value && result.value.length > 0) {
+      chunks.push(result.value);
+      totalBytes += result.value.length;
+
+      // Check if we have a complete frame
+      const combined = combineChunks(chunks, totalBytes);
+      if (isCompleteFrame(combined)) {
+        return combined;
+      }
+    } else if (result.done) {
+      // Timeout on this read, but keep trying if we don't have data yet
+      if (totalBytes > 0) {
+        // We have some data, wait a bit more then check
         await new Promise(resolve => setTimeout(resolve, 50));
       }
     }
-  } catch (error) {
-    console.error('Read error:', error);
   }
 
-  // Combine all chunks
-  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  // Return whatever we got
+  return combineChunks(chunks, totalBytes);
+}
+
+/**
+ * Helper to combine chunks into a single Uint8Array
+ */
+function combineChunks(chunks: Uint8Array[], totalLength: number): Uint8Array {
   const result = new Uint8Array(totalLength);
   let offset = 0;
   for (const chunk of chunks) {
     result.set(chunk, offset);
     offset += chunk.length;
   }
-
   return result;
 }
 
 /**
- * Send command and receive response
+ * Check if we have a complete frame based on LEN byte
  */
-export async function transceiveSerial(
-  device: SerialDevice,
-  command: Uint8Array,
-  timeout: number = 2000
-): Promise<Uint8Array> {
-  // Clear any pending data first
-  if (device.reader) {
-    try {
-      // Quick read to clear buffer
-      const clearPromise = device.reader.read();
-      const quickTimeout = new Promise<{ done: true }>((resolve) =>
-        setTimeout(() => resolve({ done: true }), 50)
-      );
-      await Promise.race([clearPromise, quickTimeout]);
-    } catch {
-      // Ignore clear errors
-    }
-  }
+function isCompleteFrame(data: Uint8Array): boolean {
+  if (data.length < 4) return false;
 
-  await sendSerialData(device, command);
+  const len = data[0];
+
+  // Known frame sizes for ASK RDR-518:
+  // LEN=0x04: no-card response, total 8 bytes (4 + 2 data + 2 CRC)
+  // LEN=0x0b: card-found response, total 15 bytes
+  if (len === 0x04 && data.length >= 8) return true;
+  if (len === 0x0b && data.length >= 15) return true;
 
-  // Small delay to allow device to process
-  await new Promise(resolve => setTimeout(resolve, 50));
+  // Generic check: LEN + 4 bytes (header estimate)
+  if (data.length >= len + 4) return true;
 
-  return await receiveSerialData(device, timeout);
+  return false;
 }
 
 /**
@@ -212,7 +265,7 @@ export function getSerialPortInfo(port: SerialPort): string {
   const info = port.getInfo();
 
   if (info.usbVendorId === 0x1fd3 && info.usbProductId === 0x0108) {
-    return 'RDR-518 NFC Reader';
+    return 'ASK RDR-518';
   }
   if (info.usbVendorId === 0x072f) {
     return 'ACS NFC Reader';