for RFID Tag Collision

guineanscarletElectronics - Devices

Nov 27, 2013 (3 years and 6 months ago)


Adaptive Splitting Protocols
for RFID Tag Collision

Jihoon 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

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

no need to have line of
sight (bar code requires optical view).

Easier to have a unique ID for each

Could also be used for other

medical applications

health monitoring etc.

What are the Networking

My take

Collision Avoidance

large number
of tags communicating with a small
number of readers.

Load balancing between readers.

Are there issues similar to hidden
terminals ? Need to be addressed.

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


Problem Description

Prior algorithms

why they are
inefficient ?

Changes proposed to these algorithms
in this paper.

Performance results.

Open discussion.


Simultaneous transmissions in RFID
lead to collisions.

Increase in transmission delay, overhead.

Two types of collisions:

Reader collisions

readers query a tag

Tag collisions

Multiple tags transmit IDs
to a reader.


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

This recognition should happen with

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

but could incur delays.

Split colliding tags into subsets and try to
recursively do this until a subset has only a single

Key Idea in this paper

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

This is a useful technique

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

Binary Tree Protocol

Each tag has a counter

initialized to zero.

A tag is also allowed to transmit when its counter is

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

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

all collisions resolved within the

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

Reader queries with a bit string

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

QT is memoryless

tags need not maintain
counter values and remember what has

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

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

However, there may be newly arriving tags and
tags that leave

these need to be accounted for.


Adaptive Query Splitting

a variant of
the QT approach.

Adaptive Binary Splitting

a variant of
the Binary Tree Protocol.


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

Collision cycle


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

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

ABS: Details

A tag has two counters

Progressed Slot
Counter (PSC) and Allocated Slot Counter

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

They randomly choose either 1 or a 0 and adds it to

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

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

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

Cognitive radio ? What are the
challenges ?

Others ?