Access Sequence APIs

Applicable Devices : RFD40, RFD90, RFD8500

Overview

An access sequence lets you queue several tag operations (read, write, and so on) and run them together. The workflow has three steps:

  1. Buffer Management: build the list of operations to run.
  2. Execution and Control: start and stop the sequence.
  3. Monitoring and Tag Retrieval: get the results and the tag data.

In the samples, apiInstance is your SDK instance and readerID is the ID of the connected reader.

Buffer Management

Build the list of operations to run.

Creating operations


srfidAccessParameters *readOp = [[srfidAccessParameters alloc] init];
readOp.accessOperationCode = SRFID_ACCESSOPERATIONCODE_READ;
readOp.memoryBank = SRFID_MEMORYBANK_USER;
readOp.offset     = 0;      // start word
readOp.length     = 4;      // number of words
readOp.password   = 0;      // access password (0 if none)

srfidAccessParameters *writeOp = [[srfidAccessParameters alloc] init];
writeOp.accessOperationCode = SRFID_ACCESSOPERATIONCODE_WRITE;
writeOp.memoryBank  = SRFID_MEMORYBANK_USER;
writeOp.offset      = 0;
writeOp.dataToWrite = @"AABB0011";   // hex string
writeOp.password    = 0;

srfidAccessSequenceDeleteAll

Clears all queued operations. Call it before building a new sequence.


NSString *statusMessage = nil;
SRFID_RESULT result = [apiInstance srfidAccessSequenceDeleteAll:readerID
                                                aStatusMessage:&statusMessage];

srfidAccessSequenceAdd

Adds one operation to the queue.


[apiInstance srfidAccessSequenceAdd:readerID aAccessParameters:readOp  aStatusMessage:&statusMessage];
[apiInstance srfidAccessSequenceAdd:readerID aAccessParameters:writeOp aStatusMessage:&statusMessage];

srfidAccessSequenceGetLength

Returns the number of operations currently queued.


int count = [apiInstance srfidAccessSequenceGetLength:readerID];

srfidAccessSequenceGetOperation

Returns the operation at a given index, or nil if the index is out of range.


srfidAccessParameters *op = [apiInstance srfidAccessSequenceGetOperation:readerID atIndex:0];
if (op == nil) {
    // Index out of range
}

srfidAccessSequenceDelete

Removes a specific operation. Pass the same object you added; a different object with identical values won't match.


SRFID_RESULT result = [apiInstance srfidAccessSequenceDelete:readerID
                                          aAccessParameters:writeOp
                                             aStatusMessage:&statusMessage];

srfidGetMaxNumOperationsInAccessSequence

Returns the maximum number of operations the reader supports in one sequence.


int maxOps = [apiInstance srfidGetMaxNumOperationsInAccessSequence:readerID];
if ([apiInstance srfidAccessSequenceGetLength:readerID] >= maxOps) {
    // Sequence is full; don't add more operations
}

Execution and Control

Start and stop the queued sequence.

srfidAccessSequencePerform

Runs the queued operations on tags that match a filter. The call starts the sequence and returns; call srfidAccessSequenceStop when you want it to end.


srfidTagFilter *filter = [[srfidTagFilter alloc] init];
[filter setFilterMaskBank:SRFID_MEMORYBANK_EPC];
[filter setFilterMaskStartPos:32];       // bit position (32 = start of the EPC)
[filter setFilterData:@"E2801160"];      // hex pattern to match
[filter setFilterMatchLength:32];        // bits
[filter setFilterDoMatch:YES];

srfidAccessCriteria *criteria = [[srfidAccessCriteria alloc] init];
criteria.tagFilter1 = filter;

NSString *statusMessage = nil;
SRFID_RESULT result = [apiInstance srfidAccessSequencePerform:readerID
                                             aAccessCriteria:criteria
                                              aStatusMessage:&statusMessage];
if (result != SRFID_RESULT_SUCCESS) {
    NSLog(@"Could not start sequence: %@", statusMessage);
}

srfidAccessSequencePerformNoFilter

Runs the queued operations on all tags in range.


SRFID_RESULT result = [apiInstance srfidAccessSequencePerformNoFilter:readerID
                                                      aStatusMessage:&statusMessage];

srfidAccessSequenceStop

Stops a running sequence.


SRFID_RESULT result = [apiInstance srfidAccessSequenceStop:readerID
                                           aStatusMessage:&statusMessage];

Monitoring and Tag Retrieval

Get the results and the tag data of the last sequence.

srfidGetLastAccessResult

Returns how many unique tags succeeded and failed in the last sequence. Call it after srfidAccessSequenceStop.


int successCount = 0, failureCount = 0;
SRFID_RESULT result = [apiInstance srfidGetLastAccessResult:readerID
                                             aSuccessCount:&successCount
                                             aFailureCount:&failureCount];
NSLog(@"Succeeded: %d, Failed: %d", successCount, failureCount);

srfidGetReadTags

Retrieves up to aMaxTags tags read during the sequence, including their memory bank data. Tags that are returned are removed from the SDK's buffer, so call it again to get any remaining tags.


NSArray *tags = nil;
SRFID_RESULT result = [apiInstance srfidGetReadTags:readerID aTagData:&tags aMaxTags:50];
if (result == SRFID_RESULT_SUCCESS) {
    for (srfidTagData *tag in tags) {
        NSLog(@"Tag: %@  Data: %@  Succeeded: %d",
              [tag getTagId], [tag getMemoryBankData], [tag getOperationSucceed]);
    }
}

Complete Example


NSString *statusMessage = nil;

// 1. Build the sequence
[apiInstance srfidAccessSequenceDeleteAll:readerID aStatusMessage:&statusMessage];
[apiInstance srfidAccessSequenceAdd:readerID aAccessParameters:readOp aStatusMessage:&statusMessage];

// 2. Run it
if ([apiInstance srfidAccessSequencePerformNoFilter:readerID aStatusMessage:&statusMessage] == SRFID_RESULT_SUCCESS) {

    // ... let the sequence run, then stop it ...
    [apiInstance srfidAccessSequenceStop:readerID aStatusMessage:&statusMessage];

    // 3. Collect results
    int ok = 0, failed = 0;
    [apiInstance srfidGetLastAccessResult:readerID aSuccessCount:&ok aFailureCount:&failed];

    NSArray *tags = nil;
    [apiInstance srfidGetReadTags:readerID aTagData:&tags aMaxTags:100];
}

Notes

  • Add at least one operation before starting a sequence, and keep the count within the limit returned by srfidGetMaxNumOperationsInAccessSequence. Otherwise the start call returns a failure result, with details in aStatusMessage.
  • Always check the returned SRFID_RESULT and read aStatusMessage when a call fails.