Developing application for Motorola RFID readers

Ritesh Gupta

RFID

VALUE

PROPOSITION

RFID IS:

• AN AUTOMATED, BULK DATA CAPTURE

TECHNOLOGY

• THAT ALLOWS A BUSINESS TO MORE

EFFICIENTLY MOVE, COUNT AND TRACK

PRODUCTS AND ASSETS

IMPROVES

EFFICIENCY

REDUCES

LABOR COSTS

INCREASES

PRODUCTIVITY

INCREASES

ACCURACY

INCREASES

SALES

By automating inventory and data capture tasks

By increasing automation and reducing manual

processes

By providing a 10X improvement in counting productivity

By reducing the errors associated with manual processes

By having the right product in the right place at the right time

RFID VALUE PROPOSITION

RFID IS: • An automated, bulk data capture technology

• That allows a business to more effectively move, count and track products and assets

RFID Product Suite

Industrial • Warehousing & Distribution

• Supply Chain

• Manufacturing

• Energy

Business • Retail Inventory Management

• Asset Management

• File tracking

• Healthcare

Handheld Fixed

FX9500 MC9090-Z

Mobile

RD5000

DS9808-R

Hands-Free

MC3190-Z

Handheld

FX7400

Fixed

XR480

Fixed

FX7500

Jan 15

2014

RFD5500

RFID Sled

Oct 31

2013

Motorola FX7500 : Business Class RFID Reader with Motorola Radio Technology

Connectivity: Ethernet 10/100 with MDI/MDX, Auto-negotiate

Wi-Fi with select adaptors via USB

Bluetooth with select adaptors via USB

System: Linux O.S. ver. 2.6.32

256 MB RAM / 512 MB Flash

Dual Stack IPv6 & IPv4 support

Zero Configuration Networking

Interface: USB Host & Client Port

Optically – Isolated GPIO (2 IP, 3 OP)

Reader Mounting Bracket

Power: POE or POE+

+24V DC Universal Power Supply

+12V to +48V DC Operation

Low Power Idle Mode

Environmental Specifications: Plenum Rated

MIL-Std-810G

-20 C to +50 C

RoHS

Motorola Radio Technology: Fast Read Rates, 1200+ tags / sec

High Sensitivity - 82 dBm

Excellent Noise Rejection

Adaptive Intelligence

4 high performance monostatic antenna ports

Accessories Range of Antennas

RF Cables & Brackets

+24VDC Power Supply

POE/POE+ rated Power Injector

Design and Ergonomics: Compact, stylish, blends easily into the environment

Ease of cable management - All cables on one side of the reader with smallest deployment footprint

Prominent,, Large LED’s on the reader that is easy to view from far

Enterprise Software EMDK, - RFID3 API

Java and C SDK for embedded application development

SSP 1.0

Middleware – BizTalk, Web Sphere

EPCglobal Reader Management, LLRP

Jan 15 2014

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 MC55 mobile computer

• RFD5500 Hardware* release for all mobile computer configurations

• Support for US/EU/CN SKU

October 30 2013

• Software release** for MC65 mobile computer

• Support for Japan SKU

December 2013

• Software release** for MC67 mobile computer

January 2014

RFID Applications

Host Based Applications

Non RFID MC

Wired Connection USB

Other Host Based Applications

No Support With RFID3 API or LLRP

Interface

Embedded Applications

Headless Application

Mobile 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

Applications

RFID 3 API set

LLRP Protocol

RFID Server

RFID Server running on the

Reader in background

LLRP defines a

communication interface

between RFID Readers

and Applications

Motorola RFID3 API built

based on LLRP Protocol

Customer applications in

C, C++, .NET & Java

RFID3 API Interface Architecture

DIRECT LLRP APPS

APPLICATIONS IN C

APPLICATIONS in

EMBEDDED RFID3 C-API HOST BASED RFID3 C-API

HOST BASED

RFID3 .NET-API EMBEDDED

RFID3 .NET-API

RFID Reader Server

LTK Toolkit

EMBEDDED

RFID3 Java API

HOST BASED

RFID3 Java API

Applications in

Java

Applications in

Java

• Provides Uniform API set for All

Motorola Fixed & Hand-held RFID

readers

• 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

• Java : Class interfaces are similar like

.NET (to the maximum extent)

14

RFID API3 – At a glance

RFID Reader

RFID 3 API Interface

RM/XML over

HTTP/HTTPS

LLRP Over

TCP

Mgt

Data

•Reading Tags

•Writing Tags

•Locating Tags

•Direction of Tags

Functionality of Motorola RFID

Reader

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

Using RFID3 API

Start Inventory // ---------------------------------

reader.Actions.Inventory.Perform();

// ---------------------------------

Stop Inventory // ---------------------------------

reader.Actions.Inventory.Stop();

// ---------------------------------

Using LTK Toolkit

Start Inventory 1. Build RoSpec package

2. Send the following LLRP messages to LLRP Server

ADD_ROSPEC

ENABLE_ROSPEC

START_ROSPEC

Stop Inventory 1. STOP_ROSPEC

2. DISABLE_ROSPEC

3. DELETE_ROSPEC

LESS COMPLEXITY

SAME FUNCTIONALITY

• 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

Generic LLRP Reader 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

Reader Management Interface

Application Choices

HOST PC

Non RFID MC

RFID MC

LLRP RFID API3

Application

RFID Reader READERS APPLICATION

Loopback

FIXED

HANDHELD

MOBILE

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();

APPLICATION

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

Less RFID Noise = More efficient application

S1 A S1 A S1 A S1 A

S1 A

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

Post And Access Filters

PRODUCT ON SHELF

APPLICATION

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

Software support at a glance

2011 APAC Developer Conference

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

Anatomy of a Simple Application

Initialize instance and

connect

Setup necessary

event handlers

Special settings for antennas, triggers etc…

Read tags for the duration

required Disconnect and dispose

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

Samples in .Net Samples in C Type of 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

32

Start -> Programs -> Motorola EMDK for .NET V2.4 -> Help

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) Java class in the application source code.

• Connect to the loopback address 127.0.0.1 for embedded applications

// Import RFID3 Java class

import com.mot.rfid.api3.*;

// Reader declaration

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

• Creating Event Handler Class

// Event Handler declaration

EventsHandler eventsHandler = new EventsHandler();

// EventHandler Class definition

public class EventsHandler implements RfidEventsListener

{

public EventsHandler()

{

}

// Read Tag Event funtion

public void eventReadNotify(RfidReadEvents event)

{

…

}

// 2. Event Handler function

….

}

// 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);

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!

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 calling the Inventory.perform() function.

• This function is an overloaded function that can be called in two ways:

– 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 () function can be called. It is the same irrespective of which Perform function is used.

// Start reading tags : No additional functions

reader.Actions.Inventory.perform();

// Start reading tags : Use the special triggerInfo Parameters defined

reader.Actions.Inventory.perform(null, tInfo, null);

// Stop reading tags

reader.Actions.Inventory.stop();

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…

• 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

• 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

any asset that drives their business success:

Coming

May 2010

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.

Programming Tip

Coming

May 2010

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

Programming Tip

Coming

May 2010

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

tagStorageSettings. MaxSizeMemoryBank = 128; // New maximum memory bank size: 128 bytes

rfid3Reader.Config.SetTagStorageSettings(tagStorageSettings);

Programming Tip

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)

• No line of sight requirements

• Read many tags simultaneously

• Read and write data to low-cost,

flexible tags

• Greater data capacity

• Durability

• Difficult to replicate

• BARCODES:

• Identifies CLASS of Goods

• RFID:

• Identifies EVERY Item in the World

Brings Added Value

to Existing Applications

Across Industries

ASN/Proof Of Delivery

Operator Rounds

OOS/Item-Level Visibility

Asset Management Warehouse Logistics

WIP

Manufacturing Retail

RFID Tags

On Goods & Assets

Read by Antennas &

Readers

RFID – At a Glance

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

2. LLRP Interface

3. Data Wedge

4. Microsoft BizTalk

5. IBM Web Sphere

Motorola RFID Solutions For Building Business critical applications

RFID EMDK PROGRAMMING IN MICROSOFT .NET

• 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

RFID3 API Interface

RFID API3 - Interfaces

• Login/Logout

• Get Reader Information

• Enable/Disable antenna port

• Update Software/Firmware

• Import/Export Profiles

• Get System Info

• Reboot the reader

RM Interface (HTTP)

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

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

S0 S1 S2 S3

A/B A/B A/B A/B

Tags provide 4 sessions (denoted S0, S1, S2, and S3) and maintain an

independent inventoried flag for each session