Adaptive Splitting Protocols for RFID Tag Collision

ArbitrationJihoon Myung and Wonjun Lee

ACM Mobihoc 06

RFID Systems -- what are they?

An automatic identification system -- used in tracking objects.

Typically large volumes of objects -- each object has a tag.

A limited number of readers are used to track the tags.

Readers send out signals that supplies power and instructions to tags.

Tags would then respond with their IDs -- used by the reader to track the corresponding object.

Motivation for RFID

Replaces bar-code based identification methods -- no need to have line of sight (bar code requires optical view).

Easier to have a unique ID for each object.

Could also be used for other applications -- medical applications -- health monitoring etc.

What are the Networking Issues? -- My take

1. Collision Avoidance -- large number of tags communicating with a small number of readers.

2. Load balancing between readers.3. Are there issues similar to hidden

terminals ? Need to be addressed.4. Reader mobility -- something that

could help. Does this bring about other issues ?

In this paper ...

The goal is collision avoidance. Typically, if there are a large number of

transmitters, sending low amounts of data, tree splitting algorithms are used.

The goal is to increase the efficiency of such algorithms for the scenario under consideration.

Roadmap

Problem Description Prior algorithms -- why they are

inefficient ? Changes proposed to these algorithms

in this paper. Performance results. Open discussion.

Problem

Simultaneous transmissions in RFID lead to collisions.• Increase in transmission delay, overhead.

Two types of collisions:• Reader collisions -- readers query a tag

simultaneously.• Tag collisions -- Multiple tags transmit IDs

to a reader.

Requirements/Constraints

Reader should recognize tags within its range. (Note reader does not know how many tags are present).

This recognition should happen with efficiency -- objects may move -- it may be important to track the trajectories.

Finally, resources are important -- tag has low power (obtained from reader), limited memory and low computational power.

Random Access

Aloha & Slotted Aloha -- good for the scenario under consideration but collisions can happen. • Tag starvation -- some tags may not be identified

for long times. Tree based protocols -- binary tree protocol

and query tree protocol -- do not cause starvation -- but could incur delays.• Split colliding tags into subsets and try to

recursively do this until a subset has only a single tag.

Key Idea in this paper

Use information in previous round to make decisions in current round.

This is a useful technique -- current protocols tend to ignore the fact that this information is available.

Two approaches are proposed -- one a variant of the query tree protocol and the other a variant of the binary tree protocol.

Binary Tree Protocol

Each tag has a counter -- initialized to zero. A tag is also allowed to transmit when its counter is

zero.• So, in the beginning there are collisions.

Reader transmits a feedback message to inform tags of collisions.

Upon collision, a tag randomly chooses a binary number that is added to its counter.

With this, at the next attempt, only those tags whose numbers are less than Max/2 transmit (set split into two sub-sets).

The process continues.

Binary Tree Protocol (cont)

When a collision occurs, a tag that is not involved in a collision, increases its counter by 1.

When a successful transmission is seen, tag decreases its counter by 1.

There is a frame structure -- (not clearly discussed) -- all collisions resolved within the frame.

A tag that is recognized does not transmit until the ongoing frame is complete.

Query Tree Protocol

The QT protocol uses tag IDs to split a set.

Reader queries with a bit string -- e.g. may begin with just sending a 0 or a 1.

If it is a 0, all tags whose IDs begin with 0 respond.

If collisions occur, then, a new query with two bits is sent and so on.

QT (continued)

The process terminates when all tags are recognized.

QT is memoryless -- tags need not maintain counter values and remember what has happened -- based on IDs.

However, there is a delay penalty. There may be queries that may produce

nothing since tags corresponding to the particular IDs may not be within the reader’s footprint.

The Problem with BT and QT

The problem that the authors identify is that the algorithms are started from scratch at the beginning of each frame.

However, many tags may be still within the reader’s footprint. Thus, it is probably not a good idea to go through collisions and resolution again.

Since the reader already has some information about the staying tags, it should use this information.

However, there may be newly arriving tags and tags that leave -- these need to be accounted for.

Contributions

Adaptive Query Splitting -- a variant of the QT approach.

Adaptive Binary Splitting -- a variant of the Binary Tree Protocol.

Definitions/Observations

A frame in a tree-based approach is represented by a tree structure.

Three kinds of cycles -- • Idle Cycle -- no transmission• Readable Cycle -- exactly one

transmission• Collision cycle -- collision

In the tree structure -- all leaves are either idle cycles or readable cycles.

Adaptive Query Splitting

The key idea is to maintain two queues Q and CQ.

Q contains queries to be made. CQ contains leaves. At the beginning of a frame, contents of

CQ are first moved to Q. During the frame, CQ compiles the

readable and idle cycles.

Query Deletion

• As empty cycles are discovered (due to nodes leaving), the process prunes out empty cycles thereby reducing the height of the tree.

Algorithmic Representation

Adaptive Binary Splitting

ABS starts tag identification from the readable cycles of the previous frame and uses random numbers for the splitting procedure.

It avoids the delays that may be incurred due to empty cycles in AQS.

Staying tags revise their counters into the order in which they were recognized in the last frame.

Arriving tags choose a counter value at random.

ABS: Details

A tag has two counters -- Progressed Slot Counter (PSC) and Allocated Slot Counter (ASC).

PSC is initially `0’ and is increased by `1’ only in a readable cycle. • Same for all tags • A readable cycle is made known by the reader.

ASC signifies the cycle in which a tag can transmit its ID.

A tag is allowed to transmit if ASC=PSC.

ABS: More Details

If ASC < PSC, tag has already been recognized -- does nothing.

Upon collision, colliding tags increase their ASCs.• They randomly choose either 1 or a 0 and adds it to ASC.• Tags which have ASC greater than PSC will also

increase their ASCs by 1 to prevent collisions from tags that increase their ASCs as above.

Since PSC is unchanged, tags that add a `0’ contend in the next cycle and so on.• Note that this set will be resolved before the set that

chooses a `1’.

ABS: Even More Details

In each idle cycle, the tag that has not been recognized but with ASC > PSC will decreases its ASC by 1.

At the end of a frame, a recognized tag gets a unique ASC.

It preserves this ASC in the next frame -- this makes the search process much more efficient.

Terminated Slot Counter

Another slot counter called the terminated slot counter (TSC) is maintained.

TSC is increased each time there is a collision (note collision indicates at least two nodes transmitting with the specific ASC).

In the first cycle, the reader begins with a TSC of zero and goes with the TSC at the end of the frame to the next frame.

If there are collisions in the next frame, TSC is automatically increased.

Thus, this adaptively tries to keep track of the tags in the system.

Process terminates when PSC > TSC.

Miscellaneous details

Authors do not prove correctness --somewhat important.

Performance analysis conducted for worst case delay estimation.

The delays are computed assuming that the reader footprints are independent of each other -- in fact the algorithms also work with this assumption.• Else, collision among tags from different reader

footprints can occur; there is no discussion on how this can be addressed.

Sample Performance Results

• Generic spirit of the results suggests that collisions go down, the overhead is decreased (reduced collisions) and delay decreases.

• Variety of parameters considred (won’t go into it.).

My take

RFID systems need more careful assessment -- how much is the memory of the tags, how much is the processing capability ?

Can whatever we design apply given realistic values of these ?

How do supply chain systems work ? Is there an interfacing issue with databases and RFID tags -- how long does it take to query etc. ?

Realism is the key !

In the larger context...

I think it is important to identify interesting topics or applications.

Understand what are the networking implications in this new setting.

RFID is one such technology/application.

Cognitive radio ? What are the challenges ?

Others ?