for RFID Tag Collision

guineanscarletElectronics - Devices

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

59 views

Adaptive Splitting Protocols
for RFID Tag Collision
Arbitration

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
--

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 ?