Developing application for Motorola RFID

readers

Ritesh Gupta
RFID VALUE
RFID
PROPOSITION RFID IS:
• AN AUTOMATED, BULK DATA CAPTURE
TECHNOLOGY
VALUE
RFID IS:
PROPOSITION
• An automated, bulk data capture technology
• THAT ALLOWS A BUSINESS TO MORE
• That allows a business to more EFFICIENTLY
effectively move, countCOUNT
MOVE, and track
ANDproducts
TRACK and assets
PRODUCTS AND ASSETS
IMPROVES By automating inventory and data capture tasks
EFFICIENCY

REDUCES By increasing automation and reducing manual

LABOR COSTS processes

INCREASES By providing a 10X improvement in counting productivity

PRODUCTIVITY

INCREASES By reducing the errors associated with manual processes

ACCURACY

INCREASES By having the right product in the right place at the right time
SALES
RFID Product Suite
Fixed Fixed Handheld Mobile
Industrial
• Warehousing & Distribution
• Supply Chain
• Manufacturing
• Energy

FX9500 XR480 MC9090-Z RD5000

Fixed Handheld Hands-Free

Business
• Retail Inventory Management
• Asset Management RFID Sled
• File tracking
• Healthcare RFD5500
FX7500

FX7400 MC3190-Z DS9808-R

Jan 15 Oct 31
2014 2013
 Motorola FX7500 : Business Class RFID Reader with Motorola Radio Technology

Motorola Radio Technology: Enterprise Software

 EMDK, - RFID3 API
 Fast Read Rates, 1200+ tags / sec
 Java and C SDK for embedded application
 High Sensitivity - 82 dBm development
 Excellent Noise Rejection  SSP 1.0
 Adaptive Intelligence  Middleware – BizTalk, Web Sphere
 4 high performance monostatic antenna ports  EPCglobal Reader Management, LLRP

Design and Ergonomics:

 Compact, stylish, blends easily into the environment System:
 Ease of cable management - All cables on one side of  Linux O.S. ver. 2.6.32
the reader with smallest deployment footprint  256 MB RAM / 512 MB Flash
 Prominent,, Large LED’s on the reader that is easy to  Dual Stack IPv6 & IPv4 support
view from far  Zero Configuration Networking

Interface:
 USB Host & Client Port
Connectivity:  Optically – Isolated GPIO (2 IP, 3 OP)
 Ethernet 10/100 with MDI/MDX, Auto-negotiate Jan 15  Reader Mounting Bracket
 Wi-Fi with select adaptors via USB 2014
 Bluetooth with select adaptors via USB

Environmental Specifications: Power: Accessories

 Plenum Rated  POE or POE+  Range of Antennas
 MIL-Std-810G  +24V DC Universal Power Supply  RF Cables & Brackets
 -20 C to +50 C  +12V to +48V DC Operation  +24VDC Power Supply
 RoHS  Low Power Idle Mode  POE/POE+ rated Power Injector
Motorola RFD5500 UHF RFID Sled
• UHF RFID sled for MC55, MC65 & MC67 (Windows version
only)
• Performance Similar to MC319Z
• Gun form-factor
• Dedicated 2nd battery for RFID
• Compatible with most MC55 accessories
• Uses same API as on MC319Z and MC919Z (“RFID3”)

• Software release** for • Software release** for • Software release** for

MC55 mobile computer MC65 mobile computer MC67 mobile computer

• RFD5500  Hardware* • Support for Japan SKU

release for all mobile
computer configurations

• Support for US/EU/CN

SKU
October 30 2013 December 2013 January 2014
RFID Applications
Host Based Applications

Non RFID MC
Other Host Based Applications

Wired Connection
USB

No Support With
RFID3 API or LLRP
Interface
Embedded Applications

Mobile
Application

Headless
Application
LLRP - Low Level Reader Protocol
What is LLRP?
• Low Level Reader Protocol, defined by the EPC Global organization
• Open standard protocol that defines communication interface between readers
and applications.
• Message-oriented protocol
• Messages from the Client to the Reader include:
• Getting and setting configuration of Readers, reader’s capabilities
discovery
• Managing the inventory and access operations

• Messages from the Reader to the Client include:

• Reporting of Reader status, inventory and access results, and various
events

• The standard RFID interface to Motorola mobile as well as Motorola fixed readers

http://www.gs1.org/gsmp/kc/epcglobal/llrp
Motorola RFID System
Customer applications in
Applications C, C++, .NET & Java

RFID 3
API set Motorola RFID3 API built
based on LLRP Protocol

LLRP
Protocol LLRP defines a
communication interface
between RFID Readers
and Applications

RFID
Server
RFID Server running on the
Reader in background
RFID3 API Interface Architecture

Applications in Applications in
APPLICATIONS in
Java Java

EMBEDDED EMBEDDED HOST BASED HOST BASED

RFID3 Java API RFID3 .NET-API RFID3 .NET-API RFID3 Java API

APPLICATIONS IN C

EMBEDDED RFID3 C-API HOST BASED RFID3 C-API

DIRECT LLRP APPS

LTK Toolkit

RFID Reader Server

RFID API3 – At a glance
• Provides Uniform API set for All
Motorola Fixed & Hand-held RFID RFID 3 API Interface
readers
• Support multiple readers access and is

Data
Mgt
thread-safe
• Designed for fast application
development to support both simple
RM/XML over LLRP Over
and advanced Reader Operations.
HTTP/HTTPS TCP
• Provide a Full-fledged user-friendly
interface
• Java : Class interfaces are similar like
.NET (to the maximum extent)
RFID Reader

14
Functionality of Motorola RFID
Reader
•Reading Tags
•Writing Tags
•Locating Tags
•Direction of Tags
LLRP Specific Functionality
2 Major Operations
Reader Operations – Antenna Inventory
Access Operations – Read, Write Tag’s Memory
Comparison Between Using
RFID3 API And LTK Toolkit
SAME FUNCTIONALITY

Using RFID3 API Using LTK Toolkit

Start Inventory Start Inventory
// --------------------------------- 1. Build RoSpec package
reader.Actions.Inventory.Perform(); 2. Send the following LLRP messages to LLRP Server
// ---------------------------------  ADD_ROSPEC
 ENABLE_ROSPEC
 START_ROSPEC

Stop Inventory
// --------------------------------- Stop Inventory
reader.Actions.Inventory.Stop(); 1. STOP_ROSPEC
// --------------------------------- 2. DISABLE_ROSPEC
3. DELETE_ROSPEC

LESS COMPLEXITY
 Generic LLRP Reader Interface
• Talks with LLRP based Motorola Readers via LLRP interface

• Allows applications to perform:

• Connection Management
• Knowing Reader Capabilities
• Configuring the Reader
• Managing Events
• Managing Tags
• Setting Filters and Triggers
• Inventory & Access Operations

17
 Reader Management Interface
• Talks over the custom interface as supported by Reader
• Via xml over http (for XR Series, FX Series)
• Via custom LLRP extensions (for MC3090Z, MC3190Z, MC9090Z)

• Allows application to perform

• Login/Logout
• Get Reader Information
• Change Antenna Mode (only for XR Series)
• Enable/Disable antenna port (only for XR Series, FX Series)
• Update Software/Firmware
• Import/Export Profiles (only for XR Series, FX Series)
• Get System Info (only for XR Series, FX Series)

18
 Application
Application Choices
RFID LLRP
API3
APPLICATION READERS
RFID Reader

HOST PC
FIXED
Loopback

RFID MC
HANDHELD

MOBILE

Non RFID MC
A Simple “Inventory” Code Snippet
// Establish connection to the RFID Reader
RFIDReader reader = new RFIDReader("157.235.88.153", 0, 0);
reader.Connect();

// Specify that TagData should be reported along with the ReadNotify Event
// Handler
reader.Events.AttachTagDataWithReadEvent = true;
// registering for read tag event notification
reader.Events.ReadNotify += new Events.ReadNotifyHandler(Events_ReadNotify);

// perform simple inventory

reader.Actions.Inventory.Perform();
// Read for 5 seconds
Thread.Sleep(5000);
// stop the inventory
reader.Actions.Inventory.Stop();

// Disconnects reader and performs clean-up

reader.Disconnect();
Inventory With No Singulation
PRODUCT ON SHELF

APPLICATION
Inventory With No Singulation
PRODUCT ON SHELF

APPLICATION
Inventory With Singulation – S1
PRODUCT ON SHELF
S1 A S1 A S1 A S1 A

S1 A

APPLICATION
Inventory With Singulation S1
PRODUCT ON SHELF
S1 A S1 A S1 A S1 A

Less RFID Noise

S1 A
= More efficient application

APPLICATION
Pre-filtering
PRODUCT

Pre-Filter:
Pre-filter are same as the
Select command of C1G2
specification.

Once applied, pre-filters are

applied prior to Inventory
and Access operations

APPLICATION
Post And Access Filters

PRODUCT ON SHELF

Post-Filter
Post-filter is the filter which is applied on the
Tags that reader already read but not yet
returned to application

Access-Filter
Access-filter is used to filter tags on which the
access commands would be applied

APPLICATION
Software support at a glance
 Programming for the FX7500

• Understand the simplicity of writing a Embedded Java application using RFID3

API provided via the Motorola RFID Embedded SDK in the hext few slides

2011 APAC Developer Conference

 Anatomy of a Simple Application
Special settings
for antennas,
triggers etc…
Setup Read tags for
necessary the duration
event handlers required Disconnect
and dispose
Initialize
instance and
connect
RFID3 API Interface Download

The EMDKs can be downloaded from Motorola support website:

http://support.symbol.com/

RFID3 API Programmer Guide & RFID3 Sample Applications

Samples In VS2005 And VS2008

EMDK samples list

Type of
Samples in .Net Samples in C application Target devices

CS_RFID3_Host_Sample1 BasicRFIDHost1 Host based FX series, XR(with LLRP)

CS_RFID3_Host_Sample2 RFIDHostSample1 Host based FX series, XR(with LLRP)

CS_RFID3_Sample3 BasicRFID2 Embedded FX740x, XR(with LLRP)

CS_RFID3_Sample4 RFIDSample4 Embedded FX740x, XR(with LLRP)

CS_RFID3_Sample5 BasicRFID1 Embedded MC3x90-Z and MC9x90-Z

CS_RFID3_Sample6 RFIDSample3 Embedded MC3x90-Z and MC9x90-Z
API3 for .NET Reference Guide
Start -> Programs -> Motorola EMDK for .NET V2.4 -> Help

32
API3 for .NET Sample
Application Guide

33
 Download Links
The EMDKs can be downloaded from Motorola support website:

• EMDK for C version 2.7 CLICK HERE

• EMDK for .NET version 2.8 CLICK HERE

• RFID Java API v1.0 CLICK HERE

Thank You
WRITING APPLICATIONS WITH MOTOROLA RFID SDK FOR JAVA
 Initialize Instance and Connect
• Include the Symbol.RFID.API3.jar library in
the Referenced Libraries section of
embedded Java project of Eclipse
(Motorola FX7500 Embedded SDK)

• Import the RFID3 API (com.mot.rfid.api3) // Import RFID3 Java class

Java class in the application source code. import com.mot.rfid.api3.*;

• Connect to the loopback address // Reader declaration

127.0.0.1 for embedded applications RFIDReader reader = null;

// Initialization for embedded applications

reader = new RFIDReader();
reader.setHostName(127.0.0.1); // local ip address
reader.setPort(5084); // default LLRP port
// Connecting to reader
reader.connect();
 Setup Necessary Event Handlers
• Declaring Event Handler // Event Handler declaration
EventsHandler eventsHandler = new EventsHandler();

• Creating Event Handler Class // EventHandler Class definition

public class EventsHandler implements RfidEventsListener
{
public EventsHandler()
{
}

// Read Tag Event funtion

public void eventReadNotify(RfidReadEvents event)
{
…
}

// 2. Event Handler function

….
}
 Setup Necessary Event Handlers (cont.)
• Registering and Adding Event s (eg. Tag-
Read-Event)
• The application can also register for all
other events and get notified when they
happen.
Eg :
– GPI is trigged
– Reader is disconnected
– … others
NOTE: All events should be defined before command
to add events to Event Handler is executed!
// defining Tag Read Event
reader.Events.setTagReadEvent(true);
// adding event(s) to Event Handler
reader.Events.addEventsListener(eventsHandler);
// defining Tag Read Event
reader.Events.setGPIEvent(true);
// defining Tag Read Event
reader.Events.setReaderDisconnectEvent(true);
// defining Tag Read Event
reader.Events.setBufferFullEvent(true);
 Special Settings
• Three parameters/structures can be passed into the main read function
Inventory.perform(PostFilter postFilterInfo, TriggerInfo triggerInfo, AntennaInfo antennaInfo) to ensure that
defined conditions are enforced when the reader is attempting to read tags and perform
inventory operations:
- PostFilterInfo
- If the data is to be filtered before being passed back to the application AFTER tags have already been
read by the radio.
- TriggerInfo
- If special start and stop conditions need to be used to start and stop RF polling
- Eg : Start polling when Input 1 is triggered and stop polling when input 1 is not triggered anymore
- Eg : Stop polling after Inventory ran for a specific time
- The tag data can also be filtered using the TagEventReport parameters to only report tags under
specific conditions and reduce the tag effort that the application has to put in.
- AntennaInfo
- Certain antenna specific parameters can be set such as ‘Transmit power’
- The readers can also be told to read tags in such a way that only a specific number of tags respond.
This is also called pre-filter.
- This number of tags is filtered in this case at the air protocol level itself.
 Special Settings for Triggers
• Trigger-Info Settings Examples:
– 1. Stop inventory after duration set in Stop
Trigger properties
– 2. Report only new tags back to the
application
// -- Setting Stop Trigger for read duration of 10 seconds
public TriggerInfo triggerInfo = new TriggerInfo();
triggerInfo.StartTrigger.setTriggerType(
START_TRIGGER_TYPE.START_TRIGGER_TYPE_IMMEDIATE);
triggerInfo.StopTrigger.setTriggerType(
STOP_TRIGGER_TYPE.STOP_TRIGGER_TYPE_DURATION);
triggerInfo.StopTrigger.setDurationMilliSeconds(10000); // 10 seconds
reader.Actions.Inventory.perform(null,triggerInfo,null);
// Setting Event Reporting to receive only unique tags
public TriggerInfo triggerInfo = new TriggerInfo();
triggerInfo.setEnableTagEventReport(true);
triggerInfo.TagEventReportInfo.setReportNewTagEvent(
TAG_EVENT_REPORT_TRIGGER.IMMEDIATE);
triggerInfo.TagEventReportInfo.setReportTagBackToVisibilityEvent(
TAG_EVENT_REPORT_TRIGGER.NEVER);
triggerInfo.TagEventReportInfo.setReportTagInvisibleEvent(
TAG_EVENT_REPORT_TRIGGER.NEVER);
reader.Actions.Inventory.perform(null,triggerInfo,null);
 Special Settings for Antennas
• Antenna-Info Settings Example:
– 1. Set a specific antenna Session, Q value
to read tags
– 2. Set a specific antenna power
NOTE : Antenna power setting in the RFID-3
API is based on the LLRP functionality of the
reader. So the application should first get the
transmit power list which returns a dBm value
list that is supported by the reader. Then the
application should set the index of the
transmit power value that it wants to use
// Getting current parameters of antenna
Antennas antennas = reader.Config.Antennas;
Antennas.SingulationControl singulationControl;
singulationControl =
reader.Config.Antennas.getSingulationControl(antennaID);
// Setting Session 1
singulationControl.setSession(SESSION.SESSION_S1);
// Tag population is 6
singulationControl.setTagPopulation((short)6);
// Set the parameters for antenna
reader.Config.Antennas.setSingulationControl(antennaID,
singulationControl);
// Setting Antenna Power
Antennas antennas = reader.Config.Antennas;
Antennas.Config antennaConfig;
// set the transmit power to minimum value eg 16dBm as per value
// located at index 0 in the transmitPowerList
antennaConfig.setTransmitPowerIndex(0);
antennas.setAntennaConfig(antennaID, antennaConfig);
 Read Tags Function
• Application can start reading tags by // Start reading tags : No additional functions
calling the Inventory.perform() function. reader.Actions.Inventory.perform();

• This function is an overloaded function

// Start reading tags : Use the special triggerInfo Parameters defined
that can be called in two ways: reader.Actions.Inventory.perform(null, tInfo, null);
– If no special parameters are desired to be
passed to the reader, the Perform method
can be called by itself
– If special filter, trigger or antenna settings
are to be passed to the reader, those can
be passed to the Perform function too.
• To stop reading tags the Inventory.stop () // Stop reading tags
function can be called. It is the same reader.Actions.Inventory.stop();
irrespective of which Perform function is
used.
 Read Tags Function(cont.)
• Tag Data can be extracted in two ways
– The tag data can be pulled from the event
itself if the AttachTagdatatoEvent flag was
set to “true”
// Using the tag information that is attached to the event itself
public void eventReadNotify(RfidReadEvents e) {
TagData tagData = e.getReadEventData().tagData;
if (tagData.getTagID() != null)
{
postInfoMessage("Tag ID: “ + tagData.getTagID() +
"; Antenna ID: “ +
tagData.getAntennaID());
}
}
 Read Tags Function (cont.)
• Tag Data can be extracted in two ways
(cont.)
– Or the application can use the
getReadTags function directly. This returns
the required number of TagData[]
structures.
// Using the getReadTags function to ask the reader for tags in it’s
// buffer
public void eventReadNotify(RfidReadEvents e) {
TagData[] myTags = null;
myTags = myReader.Actions.getReadTags(50);
if (myTags != null)
{
for (int index = 0; index < myTags.length; index++)
{
TagData tag = myTags[index];
String key = tag.getTagID();
postInfoMessage("Tag ID: “ + tagData.getTagID() +
"; Antenna ID: “ +
tagData.getAntennaID());
}
}
}
 Disconnect and Dispose
• Disconnecting from the reader is as simple
as calling the disconnect() function
// Use the isConnected() function to see if the reader is connected
// and if it is required to disconnect
if (reader.IsConnected())
{
reader.disconnect();
}
KEY RFID APPLICATIONS

APPLICATIONS RETAIL CPG MANUF. HEALTH TRANSP ENERGY GOVT FINANCE

Item level Inventory

Visibility ● ● ● ●

Supply Chain
Management ● ● ● ● ● ●

Asset Tracking ● ● ● ● ●

File Management ● ● ●

IT Asset Tracking ● ● ● ●

WIP / Parts Tracking ● ● ●

People Tracking ● ● ●
Our Customers Use RFID to Track…
any asset that drives their business success:
• Traveler luggage for airports
• Document Files for law firms
• Recycling Bins for local municipalities
• Evidence for courthouses
• Containers for railways
• Evacuees and their belongings for governments
• Trucks and trailers re: yard management
• Orders and shipments for retailers
• Apparel inventory for clothing retailers
• Supplies and assets for school districts
• Pieces of art for museums
• Furniture from manufacture to store
• Medical instruments in hospitals
• Inventory for floral distributors
• Aircraft parts - repair status
Increased Visibility = Improved Efficiency & Productivity
• Automobiles for car dealerships
• Oil Drilling Equipment for energy service
providers
• Gas meters for energy companies
• Voting equipment for local
municipalities
• IT assets - data tapes, blade servers for
large financial and IT firms
• Returnable totes for retail distribution
centers
• Pallets for manufacturers and shipping
companies
• Weapons for law enforcement agencies
• Workers for a shipbuilding company
• Students for various school districts
• Buses for transportation agencies
Programming Tip

Question:
I am using the Motorola Handheld RFID reader to inventory tags and there are
over hundreds tags in the FOV. I observe that the tag read rate is quite slow
and my application responds slowly as well. Sometime the system even
crashes. What could possibly cause this issue?
Answer:
When writing embedded applications on the handheld readers, try NOT to
implement computation heavy and complex logic, like frequently update
database, play sound, communicate with server. This could have the
undesirable effect of crippling the core functionality of the RFID.

Coming
May 2010
Programming Tip

Question:
Does RFID3 API allow user to control the inventory operation via trigger button
on Hand-held reader? – Start Inventory when trigger is pulled, and stop
inventory when trigger is released

Answer:
Yes. A special trigger type is added in the RFID3 API, which is Handheld
trigger. The sample code in the next slide shows how to use handheld trigger to
control the inventory operation

Coming
May 2010
Programming Tip

Question:
Can RFID3 API support reading large-capacity tag, Eg. EPC ID > 12 byts, MB
size > 64 bytes?

Answer:
Yes. In order to read large-capacity tag, application should change the default
API tag storage settings, which are:
Maximum size of EPC Data in Bytes: 12 bytes (96 bits)
Maximum size of tag’s Memory Bank: 64 bytes(512 bits)

Change TagStorageSettings

TagStorageSettings tagStorageSettings = new TagStorageSettings();

tagStorageSettings.MaxTagIDLength = 30; // New maximum EPC ID: 30 bytes
Coming
tagStorageSettings. MaxSizeMemoryBank = 128; // New maximum memory bank size: 128 bytes May 2010

rfid3Reader.Config.SetTagStorageSettings(tagStorageSettings);
Basic Inventory
// Subscribe for Tag Read Event Notification
reader.Events.AttachTagDataWithReadEvent = false;
reader.Events.ReadNotify +=new Events.ReadNotifyHandler(Events_ReadNotify);
reader.Actions.Inventory.Perform();

// Tag Read Event Notification Handler

void Events_ReadNotify(object sender, Events.ReadEventArgs e)
{
TagData[] tags = reader.Actions.GetReadTags(500);
if (tags != null)
{
foreach (TagData tag in tags)
{
Console.WriteLine(tag.TagID);
}
}
}

// Unsubscribe the Tag Read Event Notification

reader.Events.ReadNotify -= new Events.ReadNotifyHandler(Events_ReadNotify);

// Stop the inventory

reader.Actions.Inventory.Stop();
Access - Tag Write Operation

// Write user memory bank data

string tagId = "1234ABCD00000000000025B1";

TagAccess.WriteAccessParams writeParams = new TagAccess.WriteAccessParams();

byte[] writeData = new byte[4] { 0x11, 0x22, 0x33, 0x44 };
writeParams.AccessPassword = 0;
writeParams.WriteDataLength = writeData.Length;
writeParams.MemoryBank = MEMORY_BANK.MEMORY_BANK_USER;
writeParams.ByteOffset = 0;
writeParams.WriteData = writeData;

// antenna Info is null performs on all antenna

reader.Actions.TagAccess.WriteWait(tagId, writeAccessParams, null);
Pre-Filter
// Add state unaware pre-filter
PreFilters.PreFilter filter = new PreFilters.PreFilter();

byte[] tagMask = new byte[2] { 0x12, 0x11 };

filter.AntennaID = 3;// Set this filter for Antenna ID 3
filter.TagPattern = tagMask;// Tags which starts with 0x1211
filter.TagPatternBitCount = (uint)tagMask.Length * 8;
filter.BitOffset = 32; // skip PC bits (always it should be in bit length)
filter.MemoryBank = MEMORY_BANK.MEMORY_BANK_EPC;
filter.FilterAction = FILTER_ACTION.FILTER_ACTION_STATE_UNAWARE; // use state unaware
singulation
// do not select the tags that match the pre-filter criteria
filter.StateUnawareAction.Action =
STATE_UNAWARE_ACTION.STATE_UNAWARE_ACTION_UNSELECT;
reader.Actions.PreFilters.Add(filter);

// Set the singulation control

Antennas.SingulationControl s1_singulationControl = new Antennas.SingulationControl()
// Set session to operate on S1. If not specified,
//reader uses its own way of implementing the state-unware singulation
s1_singulationControl.Session = SESSION.SESSION_S1;
reader.Config.Antennas[3].SetSingulationControl(s1_singulationControl);
Access Filter
AccessFilter accessFilter = new AccessFilter();
byte[] tagMask = new byte[8] { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };

// Tag Pattern A
accessFilter.TagPatternA.MemoryBank =
MEMORY_BANK.MEMORY_BANK_RESERVED;
accessFilter.TagPatternA.TagPattern = new byte[8] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00};
accessFilter.TagPatternA.TagPatternBitCount = 8 * 8;
accessFilter.TagPatternA.BitOffset = 0;
accessFilter.TagPatternA.TagMask = tagMask;
accessFilter.TagPatternA.TagMaskBitCount = (uint)tagMask.Length * 8;

// Tag Pattern B
accessFilter.TagPatternB = null;

//Active Filter(s)
accessFilter.MatchPattern = MATCH_PATTERN.A;
Autonomous Mode
Tag Event Reporting & Filtering capability (Helps to reduce the network traffic)
• Specifies configuration of events to report tag state changes
New Tag Event, Tag Invisible Event, Tag Back to Visible Event
• Reporting of Events can be Configured as below:
Immediate, Moderate (Subject to Timeout), Never

TriggerInfo triggerInfo = new TriggerInfo();

triggerInfo.EnableTagEventReport = true;
triggerInfo.TagEventReportInfo.ReportNewTagEvent =
TAG_EVENT_REPORT_TRIGGER.MODERATED;
triggerInfo.TagEventReportInfo.ReportTagInvisibleEvent =
TAG_EVENT_REPORT_TRIGGER.MODERATED;
triggerInfo.TagEventReportInfo.ReportTagBackToVisibilityEvent =
TAG_EVENT_REPORT_TRIGGER.MODERATED;
triggerInfo.TagEventReportInfo.NewTagEventModeratedTimeoutMilliseconds = 100;
triggerInfo.TagEventReportInfo.TagInvisibleEventModeratedTimeoutMilliseconds = 100;
triggerInfo.TagEventReportInfo.TagBackToVisibilityModeratedTimeoutMilliseconds = 100;
reader.Actions.Inventory.Perform(null, triggerInfo, null);
Custom Tag Support
• NXP Custom Tag
– Set/Reset EAS (Electronic Article Surveillance)
– Set/Reset Read Protect (Quiet bit)
– Perform EAS Scan
• Fujitsu Custom Tag
– Change Word Lock (64KB Tag)
– Change Block Lock (64KB Tag)
– Read Block Lock (64KB Tag)
– Burst Write (64KB Tag)
– Burst Erase (64KB Tag)
– Change Block or Area Group Password (Both 64KB Tag and 8KB Tag)
– Area Read Lock (8KB Tag)
– Area Write Lock (8KB Tag)
– Area Write Lock without Password (8KB Tag)
RFID – At a Glance
• No line of sight requirements
RFID Tags
• Read many tags simultaneously
• Read and write data to low-cost,
flexible tags On Goods &
• Greater data capacity Assets
• Durability
• Difficult to replicate
• BARCODES: Read by
Antennas &
• Identifies CLASS of Goods Readers
• RFID:
• Identifies EVERY Item in the World
Warehouse
Logistics
Asset Management
Operator Rounds
Brings
Added Value
OOS/Item-Level Visibility
WIP ASN/Proof Of
Delivery
to Existing
Applications

Across
Industries
Manufacturing Retail
Motorola RFID Solutions
For Building Business critical applications

1. Motorola EMDK/ SDK For C, .NET, JAVA

2. LLRP Interface

3. Data Wedge

4. Microsoft BizTalk

5. IBM Web Sphere

RFID EMDK PROGRAMMING IN
MICROSOFT .NET
 RFID3 API Interface
• Provide API set for Motorola’s LLRP based Fixed & Hand-
held readers
- Fixed Reader: XR Series (LLRP Enabled), FX7400, FX9500
- Hand-Held Reader: MC3090Z, MC3190Z, MC9090Z

• Support multiple readers access and is thread-safe

• Designed for fast application development to support both

simple and advanced Reader Operations

• Provide a Full-fledged user-friendly interface for

- Generic reader functionality (over LLRP) , and
- Reader Manageability ( over Http or custom LLRP extensions )

61
RFID API3 - Interfaces
RM Interface (HTTP)
• Login/Logout

• Get Reader Information

• Enable/Disable antenna port

• Update Software/Firmware

• Import/Export Profiles

• Get System Info

• Reboot the reader

RFID API3 - Interfaces
Generic Interface (LLRP)
• Connection Management

• Knowing Reader Capabilities

• Configuring the Reader

• Managing Events

• Managing Tags

• Setting Filters and Triggers

• Inventory & Access Operations

• Tag Locationing

• Custom Tag Support (NXP, Fujitsu)

Sessions
Tags provide 4 sessions (denoted
S0 S1 S2 S3 S0, S1, S2, and S3) and maintain an
independent inventoried flag for
A/B A/B A/B A/B each session

Singulation
State Aware – More complex – application handles
State Unaware – Reader Handles

The following are the steps to use pre-filters:

1. Add pre-filters
• Check ReaderCapabilites.MaxNumPreFilters
• Use StateUnawareAction for tag selection control

2. Set appropriate Singulation controls

• Session S0 – no select persistency
• Session S1-S3 – Tag stays ‘selected’ for configurable time

3. Perform Inventory or Access operation