RFID

Example

// Query Device Information
window.Agent.onReadyAsync()
.then(() => window.Agent)
.then(agent => agent.RFID.deviceInfo())
.then(deviceInfo => console.log(deviceInfo))
.catch(ex => {
    console.error('Failed to query card state');
    console.error(ex);
});

// This should print something similair to this:
{
  "manufacturer": "Syncotek",
  "model": "SK288-K001",
  "vendorId": 9176,
  "productId": 645,
  "serial": "ABC1234K001",
  "capabilities": [
      "LOCK",
      "UNLOCK",
      "LED-RED",
      "LED-BLUE",
      "SENSE",
      "MIFARE-CLASSIC",
      "MIFARE-PLUS",
      "MIFARE-DESFIRE"
  ]
}

Example

// Query Card Present
window.Agent.onReadyAsync()
.then(() => window.Agent)
.then(agent => agent.RFID.isCardPresent())
.then(isCardPresent => console.log(
    isCardPresent
         ? 'The card is present'
         : 'The card is not present'))
.catch(ex => {
    console.error('Failed to query card state');
    console.error(ex);
});

Example

// Query lock state
window.Agent.onReadyAsync()
.then(() => window.Agent)
.then(agent => agent.RFID.isLocked())
.then(isLocked => console.log(
    isLocked
        ? 'The latch is locked'
        : 'The latch is not locked'))
.catch(ex => {
    console.error('Failed to query lock state');
    console.error(ex);
});

Example

// Query Device Information
const RED_LED = 0;
window.Agent.onReadyAsync()
.then(() => window.Agent)
.then(agent => agent.RFID.deviceInfo()) // Check if the attached peripheral has a RED LED
.then(deviceInfo => {
     if (deviceInfo && deviceInfo.capabilities.includes('LED-RED')) return window.Agent;

     throw new Error('RED LED Not Available'); // Will throw an error an exit as we don't have an LED to control
})
.then(agent => agent.RFID.ledOff(RED_LED)) // Turn off the RED LED
.then(() => console.log('RED LED is now off'))
.catch(ex => {
    console.error('Failed to set LED state');
    console.error(ex);
});

Example

// Query Device Information
const RED_LED = 0;
window.Agent.onReadyAsync()
.then(() => window.Agent)
.then(agent => agent.RFID.deviceInfo()) // Check if the attached peripheral has a RED LED
.then(deviceInfo => {
     if (deviceInfo && deviceInfo.capabilities.includes('LED-RED')) return window.Agent;

     throw new Error('RED LED Not Available'); // Will throw an error an exit as we don't have an LED to control
})
.then(agent => agent.RFID.ledOn(RED_LED, true)) // Turn on the RED LED and flash the LED
.then(() => console.log('RED LED is now on and flashing'))
.catch(ex => {
    console.error('Failed to set LED state');
    console.error(ex);
});

Example

// Lock the latch
window.Agent.onReadyAsync()
.then(() => window.Agent)
.then(agent => agent.RFID.lock())
.then(() => console.log('Locked'))
.catch(ex => {
    console.error('Failed to Lock');
    console.error(ex);
});

Example

// Example for Querying card
const queryCard = async() => {
 console.log("QUERY CARD: Insert");
 const result = await agent.RFID.queryCard();
 console.log(result);
}
// Console Output: {
     type: 'Mifare S50 1K Card',
     uid: '02b921de',
     capacity: 1024
}

Examples

//Read Data from Ultralight cards
window.Agent.onReadyAsync()
.then(() => window.Agent)
.then(agent => agent.RFID.read(
     [
         {
             index: 5,
             blocks: [{index: 0}]
         },
         {
             index: 6
             blocks: [{index: 0}]
         }
     ],
     undefined,
     undefined,
     { skipRemove: true, skipRelease: true }
))
.then(result => {
      console.log(result);
})
.catch(ex => {
    console.error('Failed to read card data');
    console.error(ex);
});

Console Output:  {
     sectors: [
          { 
            index: 5, 
            blocks: [{index: 0, data: [1, 2, 3, 4]}]
          },
          { 
            index: 6, 
            blocks: [{index: 0, data: [5, 6, 7, 8]}]
          }
      ],
      uid: '0a0b0304050607',
      capacity: 48,
      type: 'Mifare Ultralight MF0UL11',
};

//Read Data from Mifare Classic cards
window.Agent.onReadyAsync()
.then(() => window.Agent)
.then(agent => agent.RFID.read([
    {
        index: 0,
        keys: { a: [0, 0, 0, 0, 0, 0] }
    }
]))
.then(result => {
    console.log('NUID', result.nuid);
    console.log('UID', result.uid);
    console.log('Capacity', result.capacity);

    console.log('Sectors');
    for (const sector of result.payload.sectors) {
        console.log('\tSector', sector.index);
        console.log('\t\tBlocks:');

        for (const block of sector.blocks) {
            console.log(
                '\t\t\tBlock',
                block.index,
                block.type,
                JSON.stringify(block.data),
                JSON.stringify(block.access));
        }
    }
})
.catch(ex => {
    console.error('Failed to read card data');
    console.error(ex);
});

// Example for reading with skipReadData = true
const read = async() => {
 const result = await agent.RFID.read(undefined, undefined, undefined, {
     skipInsert: true,
     skipRemove: true,
     skipRelease: true,
     skipReadData: true
 });

 console.log(result)
}

read()

Console Output:  {
 sectors: [],
 type: 'Mifare S50 1K Card',
 capacity: 1024
});

Example

// Unlock the latch
window.Agent.onReadyAsync()
.then(() => window.Agent)
.then(agent => agent.RFID.unlock())
.then(() => console.log('Unlocked'))
.catch(ex => {
    console.error('Failed to Unlock');
    console.error(ex);
});

Examples

// For Mifare Ultralight cards.
// Below example writes 8 bytes of data to sector 5 and 6 of the card.
// Ultralight card MF0UL11 contains 12 user sectors(sector index 4 to 15). Each sector has 1 block only.
// Each block contains 4 bytes of data.
window.Agent.onReadyAsync()
.then(() => window.Agent)
.then(agent => {
const writeConfig = [
          { 
            index: 5, 
            blocks: [{index: 0, data: [0x01,0x02,0x03,0x04]}]
          },
          { 
            index: 6, 
            blocks: [{index: 0, data: [0x05,0x06,0x07,0x08]}]
          },
     ];
const keys = undefined;
const inEncoding = undefined;
const writeOptions = {
            skipInsert: true,
            skipRemove: true,
            skipRelease: true,
         };
return agent.RFID.write(writeConfig, keys, inEncoding, writeOptions)

})
.then(() => console.log('Wrote to UL card successfully'))
.catch(ex => {
     if (ex instanceof AgentCancelledException) {
         console.error('It was cancelled, all is well :)');
         return;
     }
    console.error('Failed to write card data');
    console.error(ex);
});

// Write Data to Mifare Classic card Using the MeldCX Schema
window.Agent.onReadyAsync()
.then(() => window.Agent)
.then(agent => agent.RFID.write([
         {
              index: 1,
              keys: { a: [0, 0, 0, 0, 0, 0] }, // Key required to read or write.
              blocks: [
                   { index: 0, data: [4,3,2,1] }
              ],
              updateKeys: { a: [1, 2, 3, 4, 5, 6] }, // Optional update the key.
              access: {read: true, write: true, increment: true, decrement: true} // Optional update the access.
         }
    ]))
.then(() => console.log('Wrote to card successfully'))
.catch(ex => {
     if (ex instanceof AgentCancelledException) {
         console.error('It was cancelled, all is well :)');
         return;
     }
    console.error('Failed to write card data');
    console.error(ex);
});

// Write Data to Mifare Classic card Using a Base64 string of data
const base64 = 'AAECAwQFBgcIAAECAwQFBgcIAAECAwQFBgcIAAECAwQFBgcIAAECAwQFBgcIAAECAwQFBgcIAAECAwQFBgcIAAECAwQFB.....';
const keys = {a: [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], b: [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]};

window.Agent.onReadyAsync()
.then(() => window.Agent)
.then(agent => agent.RFID.write(base64, keys, 'base64'))
.then(() => console.log('Wrote to card successfully'))
.catch(ex => {
    console.error('Failed to write card data');
    console.error(ex);
});

For Mifare Classic card
//   C3[4]   C2[2]   C1[1]   Total   Access
//   1       1       0       6       Can read with Key A/B but can only write with Key B
//   1       0       0       4       Can only read and write with Key A.
//   1       1       1       7       Access can only be read by Key A/B locked to changes *permanently*
// See here for a comprehensive guide: https://www.nxp.com/docs/en/data-sheet/MF1S50YYX_V1.pdf#page=12
await agent.RFID.write([{
    index: 1,
    access: [0, 0, 0, 6]
}], {a: [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]}
* @example
// Example for writing to key B to Mifare Classic card
const writeKeyB = async() => {
 const sector = 7;
 const newKeyB = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06];
 const result = await agent.RFID.write([
     {
         index: sector,
          updateKeys: {b: newKeyB}
      }
  ], undefined, undefined, {skipInsert: true, skipRemove: true, skipRelease: true});


 console.log(result);
};

writeKeyB();

// Console Output: Undefined (no error thrown, shows that key write was successful)

// For Mifare Classic card
// Example of writing to change the access bits of a particular sector
const writeAccessBits = async() => {
 const sector = 7;
 const newAccess = [ 0, 0, 0, 6 ];
 const newPermission = [127, 7, 136];
 await agent.RFID.write([{
        index: sector,
     access: newAccess
 }], {a: [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]}, undefined, {skipInsert: true, skipRemove: true, skipRelease: true});
 const readResult = await agent.RFID.read([{
        index: sector,
     blocks: [{index: 3}]
 }], {a: [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]}, undefined, {skipInsert: true, skipRemove: true, skipRelease: true});
 const originalAccess = readResult.sectors[0].blocks[0].data.slice(6, 9);

 console.log(originalAccess)
};

writeAccessBits();

Console Output: [127, 7, 136];

// For Mifare Classic card
// Example of reseting the access to default
const resetAccess = async() => {
    const sector = 7;
    const oldAccess = [ 0, 0, 0, 4 ];
    const oldPermission = [255, 7, 128];
    await agent.RFID.write([{
        index: sector,
        access: oldAccess
    }], {b: [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]}, undefined, {skipInsert: true, skipRemove: true, skipRelease: true});
    const readResult = await agent.RFID.read([{
        index: sector,
        blocks: [{index: 3}]
    }], {a: [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]}, undefined, {skipInsert: true, skipRemove: true, skipRelease: true});
    const originalAccess = readResult.sectors[0].blocks[0].data.slice(6, 9);
}

resetAccess();

Console Output: [255, 7, 128];