Fast splitting based tag identification algorithm for anti-
collision in UHF RFID System
Article (Accepted Version)
http://sro.sussex.ac.uk
Jian, Su, Sheng, Zhengguo, Xie, Liangbo, Li, Gang and Liu, Alex X (2018) Fast splitting based
tag identification algorithm for anti-collision in UHF RFID System. IEEE Transactions on
Communications. ISSN 0090-6778
This version is available from Sussex Research Online: http://sro.sussex.ac.uk/id/eprint/80427/
This document is made available in accordance with publisher policies and may differ from the
published version or from the version of record. If you wish to cite this item you are advised to
consult the publisher’s version. Please see the URL above for details on accessing the published
version.
Copyright and reuse:
Sussex Research Online is a digital repository of the research output of the University.
Copyright and all moral rights to the version of the paper presented here belong to the individual
author(s) and/or other copyright owners. To the extent reasonable and practicable, the material
made available in SRO has been checked for eligibility before being made available.
Copies of full text items generally can be reproduced, displayed or performed and given to third
parties in any format or medium for personal research or study, educational, or not-for-profit
purposes without prior permission or charge, provided that the authors, title and full bibliographic
details are credited, a hyperlink and/or URL is given for the original metadata page and the
content is not changed in any way.
IEEE TRANSACTIONS ON COMMUNICATIONS 1
Fast Splitting Based Tag Identification Algorithm
For Anti-collision in UHF RFID System
Jian Su, Zhengguo Sheng, Liangbo Xie, and Gang Li
Abstract—Efficient and effective objects identification using
Radio Frequency Identification (RFID) is always a challenge
in large scale industrial and commercial applications. Among
existing solutions, the tree based splitting scheme has attracted
increasing attention because of its high extendibility and feasibil-
ity. However, conventional tree splitting algorithms can only solve
tag collision with counter value equals to zero and usually result
in performance degradation when the number of tags is large.
To overcome such drawbacks, we propose a novel tree-based
method called Fast Splitting Algorithm based on Consecutive
Slot Status detection (FSA-CSS), which includes a fast splitting
(FS) mechanism and a shrink mechanism. Specifically, the FS
mechanism is used to reduce collisions by increasing commands
when the number of consecutive collision is above a threshold.
Whereas the shrink mechanism is used to reduce extra idle
slots introduced by FS. Simulation results supplemented by
prototyping tests show that the proposed FSA-CSS achieves a
system throughput of 0.41, outperforming the existing UHF RFID
solutions.
Index Terms—RFID, UHF, anti-collision, FS mechanism, sys-
tem throughput, time efficiency.
I. INTRODUCTION
RFID technology has greatly revolutionized tag based appli-
cations in retail industry such as warehouse management and
inventory control [1-2]. A typical RFID system is composed
of a reader and a large number of tags attached to tracked
objects. Each object can be identified based on query response
from the attached RFID tag. However, in large scale RFID
applications, simultaneous query responses from multiple tags
can cause significant tag collisions. Since passive tags are
unable to perceive or identify such collisions, the development
of anti-collision algorithms is of great importance for fast tag
identification especially in high-density ultra high frequency
(UHF) RFID environment.
Existing tag anti-collision algorithms can be categorized
into dynamic framed slotted Aloha (DFSA)[3-5], query tree
(QT)[6-8] and binary splitting (BS) based [9-10] algorithms.
Among them, QT and BS algorithms are operated by recur-
sively dividing responding tags into smaller subsets until each
subset has at most one tag. The distinction between these two
approaches is that, in QT solutions, tags are separated by their
J. Su is with Nanjing University of Information Science and Technology,
Jiangsu 210044, China (e-mail: sj890718@gmail.com).
Z. Sheng (corresponding author) is with the Department of Engineer-
ing and Design, University of Sussex, Brighton BN1 9RH, UK (e-mail:
z.sheng@sussex.ac.uk).
L. Xie is with Chongqing University of Posts and Telecommunications,
Chongqing 400065, China (e-mail: xie.liangbo@hotmail.com).
G. Li is with University of Electronic Science and Technology of China,
Chengdu 611731, China (e-mail: ligang1986718@163.com).
Digital Object Identifier xxxx
IDs. Whereas in BS approaches, tags are divided by binary
random numbers generated in the splitting process. Strictly
speaking, QT methods are derived from the bit tracking
technology [11] which can detect the position of collided bit
by the reader. However, with an increasing number of tags, the
efficiency of such methods is deteriorated because of the wide
deviation of backscatter link frequency among tags [12-14].
As a contrary, DFSA and BS algorithms are more preferable
for UHF RFID systems. DFSA algorithms usually employ
a frame structure which contains a certain number of time
intervals (called time slots) per frame, and each tag responses
to the reader by randomly choosing a time slot using its
ID. During the identification process, the size of frame is
dynamically updated according to the number of unread tags.
When the frame size is equal to the backlog (number of unread
tags), the maximum system throughput can be achieved.
Recent works in DFSA include improved linearized combi-
natorial model (ILCM) [15] based anti-collision algorithm,
an efficient anti-collision algorithm with early adjustment of
frame length (EAAEA) [16], and access probability adjustment
based fine-grained Q-algorithm (APAFQ) [17], etc. However,
those algorithms have failed to prevent collisions completely,
because of the tag starvation problem in which a specific
tag may not be identified for a long time [9]. Furthermore,
the performance of DFSA algorithms highly depends on the
initial frame size. When the number of tags is much larger
than the size of frame, most of DFSA solutions are unable to
adjust frame size properly in order to cope with backlog, thus
lead to performance degradation [3, 15]. That is to say, DFSA
solutions are cardinality sensitive and shows inconsistent per-
formance with a wide range of backlog. As a contrary, BS
algorithms are insensitive to tag backlog particularly when the
number of tags is increased, the system throughput is almost
converged to a constant value. Although the BS approach can
tackle tag starvation, it has a relatively long identification
latency due to the splitting process starting from a single
set with all tags. Specially, the system throughput of BS
algorithms is about 0.348 [10] when the number of tags is
larger than 100. Most of recent anti-collision algorithms with
high performance are based on the integration of Aloha and
QT (or BS) algorithms [18-19]. These methods usually need
to estimate cardinality of tag population. Many efforts have
also been made to improve estimation accuracy [3-4][15][20].
However, constant estimation of number of tages with high
accuracy requires high computation overhead and thus leads
to serious challenges in implementation [16].
In this paper, we focus on the UHF RFID anti-collision
algorithm and propose a fast splitting algorithm based on
IEEE TRANSACTIONS ON COMMUNICATIONS 2
consecutive slot status detection (FSA-CSS) to improve the
identification and stability performance of BS algorithm. The
proposed solution is based on the pure BS algorithm which
is rarely investigated given concerns of marginal performance
improvement by the existing literature. Different to the existing
solutions in which the average performance is only inves-
tigated, i.e., incoming and outgoing tags are allowed to be
identified multiple times [21-22], we focus on a practice-driven
and challenging scenario in which a tag can only be identified
once and propose to improve individual performance for
identifying a batch of tags. It shows from the results that FSA-
CSS can still maintain high performance in large-scale RFID
systems without estimation of backlog. The contributions of
this paper can be summarized as follows.
1) We propose an enhanced anti-collision algorithm namely
FSA-CSS for passive UHF RFID systems. In order to ac-
celerate the splitting process, the reader allows the tags with
counter value above zero to be split into subsets in advance.
Meanwhile, the reader can avoid over-splitting by using the
shrink mechanism to reduce the extra idle slots.
2) We provide the theoretical analysis and carry out simula-
tions to evaluate the performance of FSA-CSS with a massive
number of tags. The results have been compared with various
legacy anti-collision algorithms. The optimal parameters and
performance boundaries have been derived.
3) We implement FSA-CSS in a practical UHF RFID
system, which includes a passive RFID reader and 20 tags.
The identification time of the proposed FSA-CSS is reduced by
32.5% compared to the standard BS used in ISO/IEC 18000-
6B.
The rest of this paper is organized as follows. Section
II reviews and analyzes the mainstream tag identification
strategies for UHF RFID systems. Section III discusses the
novel anti-collision algorithm FSA-CSS and analyzes its per-
formance. Section IV illustrates the simulation results. The
experimental results are presented in Section V. Finally, the
paper is concluded in Section VI.
II. RELATED WORKS
A. Binary splitting (BS) algorithm
The principle of BS algorithm is to continuously divide
collided tags into smaller subsets by using random binary
numbers. Each tag has an integer counter T
c
which is used
to record its position in the splitting process and a random
binary number generator T
R
. Different values of T
c
lead tags
into different subsets. Only tags with T
c
= 0 respond to
the reader immediately, while tags with T
c
>0 should wait
in the pipeline. At the initial stage of identification process,
all tags in reader’s vicinity should respond simultaneously
and thus are formed as one set. Depending on received
responses, the reader will send a feedback, e.g., ID-idle,
ID-collision or ID-success, to all tags for further
actions. When the feedback is ID-success or ID-idle,
all tags act T
c
= T
c
− 1. The tags already identified by the
reader will be silent during the next identification process. If
the feedback is ID-collision, the collided tags will be
divided into two subsets. Tags with T
c
= 0 add T
R
to its T
c
,
while tags with T
c
>0 increase its T
c
by 1.
The reader also uses a counter R
c
to terminate the identi-
fication process. R
c
denotes the number of unidentified tags
and its initial value is 0. When a collision occurs, the reader
performs R
c
= R
c
+ 1, given the number of identifiable
tags is increased. Otherwise, R
c
is decreased by 1. When
R
c
< 0, the identification process is ceased. Compared to
Aloha-based algorithms, the BS algorithm is insensitive to tag
cardinality particularly when the number of tags is increased.
The system throughput is almost converged to a constant value.
The work in [10] reveals that the system throughput of BS can
be maintained at 0.348 when the number of tags is above 100.
However, the BS algorithm has a relatively long identification
latency because the splitting process is started from a single
set with all tags. Moreover, it always use tag ID to perform
collision arbitration, hence there is significant space to further
improve time efficiency.
B. DFSA protocol with backlog estimation
In DFSA protocols, time is divided into a series of discrete
intervals called time slots. Several time slots are packaged
into a frame [3][15]. Each tag can randomly select a slot to
respond to the reader in each identification round. At the end
of each frame, the reader counts the number of idle, success,
and collision slots. If collision slots exist, the reader will
estimate the number of unidentified tags and adjust the frame
length accordingly. The identification process continues until
no collision occurs during a frame, i.e., all tags are successfully
identified.
It is noted that the reader needs to accurately estimate the
backlog to achieve the best performance. To improve estima-
tion accuracy, most previous methods [3-5] are implemented
with high complexity. However, typical RFID readers are
computation constrained due to the limited processing power
provided by single-chip microprocessor. As a result, estimation
methods with high computation overhead are characterized as
energy inefficient. Recently, many state-of-the-art algorithms
[15-16] have been proposed to achieve energy efficiency.
However, the system throughput of these solutions is still
below 0.36. In addition, it is worth mentioning that most of
existing DFSA studies are simulation based [3-5][15-17], thus
the practical performance cannot be verified.
C. Hybrid protocol combining DFSA with BS
So far it has been shown that the BS performs better when
the number of tags is relatively small [10]. This result has
inspired further studies to design hybrid anti-collision algo-
rithms combining DFSA and BS. The authors in [23] propose
an adaptive binary tree slotted Aloha (ABTSA) algorithm. In
ABTSA, tags are randomly assigned to slots in a frame. If
multiple tags are collided in a slot, collision will be solved
by the BS algorithm while other tags in the following slots
will be in waiting state. The benefit of using ABTSA is
that the adjustment of frame size is simplified because the
reader has the knowledge of the status in every slot and
thus can obtain an appropriate frame size accordingly. Since
the ABTSA combines both DFSA and BS algorithms, it can
achieve an average system throughput of 0.40, which is higher
IEEE TRANSACTIONS ON COMMUNICATIONS 3
than that of DFSA or BS algorithm alone. However, it is
with a complex structure, hence much more difficult to be
implemented.
In summary, aforementioned anti-collision algorithms do
provide solutions to solve the tag collision problem, how-
ever, with sacrifices in identification efficiency, complexity
and stability, etc. The characteristics of existing anti-collision
algorithms are summarized in Tab. I. In the following, we will
introduce the proposed solution based on the BS algorithm
to improve the identification efficiency of RFID system and
reduce the implementation cost.
(a,b,c,
d)
(a,c)
(b,d)
(0) (1)
c
a
(0) (1)
(2) (3)
(a,b,c,
d)
(a,c) (b,d)
c a d b
a d b
(a,d)
(0) (1)
(0) (1) (2) (2) (3)
(2)
(0) (1) (2) (3) (4)
(a,b,c,
d)
(a,c)
(b,d)
(0) (1)
(a,c)
d b
c a d b
(0) (3) (4)
(0) (1)
(2) (8) (9)
…
…
(10) (12) (13)
(a) FS with M=2, N=2 (M=N)
(b) FS with M=2, N=3 (M<N)
(c) FS with M=3, N=2 (M>N)
Collided Successful Idle
Solved by the commands from the peer node
(It will not occupy a dedicated time slot during identification)
(*) T
c
d
b
Depth 0
Depth 1
Depth 2
Depth 0
Depth 1
Depth 2
Depth 3
Depth 0
Depth 1
Depth 2
Depth 3
Depth is defined as the number of braches from that node to the root (top)
node
Fig. 1. The FS mechanism with different M and N
III. THE PROPOSED FSA-CSS ALGORITHM
A. Fast splitting mechanism
In the fast splitting (FS) mechanism, the counter value T
c
of all tags are initialized to zero. When a collision occurs, the
collided tags (i.e., tags with T
c
= 0) perform T
c
= T
c
+ T
R
,
while the tags with T
c
>0 perform T
c
= M · T
c
+ T
R
. That is,
T
c
=
T
c
+ T
R
, if T
c
= 0
M · T
c
+ T
R
, if T
c
> 0 .
(1)
where T
R
∈ {0, 1, · · ·, N − 1} denotes a random binary
number generator at an arbitrary time, N determines the
maximum subsets needed. That is to say, the collided tags can
be potentially allocated into N subsets. T
c
denotes the value
of counter at an arbitrary time. An integer M>0 is a splitting
coefficient, which denotes the splitting level of collided tags.
The larger the M , the more available subset slots can be
provided during a single splitting process.
In order to illustrate the FS mechanism, we describe a
simple case with five tags using M = N = 2. Assume the
tags a, b, c, d, e collide in the slot 0, given T
c
= 0 is for all
tags, the reader will randomly divide them into two subsets,
e.g., S
1
= {a, d, e} with random number 0 and S
2
= {b, c}
with random number 1. The FS mechanism will trigger the
reader to split S
2
into {b} and {c} in slot 1. According to (1),
no collision will happen between b and c. Meanwhile, tags a,
d, and e will collide again in slot 1 and the FS will continue
to assist the splitting until all collisions are solved. It is noted
that we consider the case where a tag can be identified only
once, whereas tags are identified repeatedly can be referred to
[9][20-21].
By generalizing cases with N>2, we can derive the follow-
ing result for the splitting coefficient M.
Result 1. The performance of FS mechanism depends on the
choice of M and leads to the following result.
M > N, yield extra idle slots
M = N, no extra idle and collision slots
M < N, yield extra collision slots
(2)
Proof: See the Appendix A.
According to the Result 1, M = N is the best choice for FS
mechanism. Examples of four tags using FS mechanism with
different M and N are illustrated in Fig. 1. The depth of a
node is defined as the path length (number of solid branches)
from that node to the root (top) node. As can be seen in Fig.
1 (a), all tags collided in slot 0 are further divided into two
subsets, e.g., S
1
= {a, c}, S
2
= {b, d}. Since tags in S
1
are
continually collided in slot 1, they act T
c
= T
c
+ T
R
, while
the tags in S
2
act T
c
= 2 · T
c
+ T
R
. After reading in slot
1, all tags are divided into four subsets. Each subset contains
only one tag. In total, the FSA-CCS consumes six slots to
identify four tags by using FS mechanism with M = N = 2.
Fig. 1 (b) shows the example of M <N . In the depth 1, tag
a acts T
c
= T
c
+ T
R
= 0 + 2 = 2, while tag d also acts
T
c
= 2 · T
c
+ T
R
= 2 + 0 = 2. As a result, two tags from
different sets generate the same T
c
, which results in an extra
collision slot. Similarly as can be observed in Fig. 1 (c), many
idle slots are introduced due to M>N. It thus indicates that
IEEE TRANSACTIONS ON COMMUNICATIONS 4
TABLE I
THE CHARACTERISTICS OF DIFFERENT ANTI-COLLISION ALGORITHMS
Method
Category
implementation
tag
starvation
cardinality
sensitive
system
throughput
identification
lantency
complexity
DFSA BS Hybrid
MAP [3]
√
medium
√ √
medium medium high
MFML-DFSA [4]
√
medium
√ √
medium medium high
FuzzyQ [5]
√
medium
√ √
low medium medium
ILCM [15]
√
easy
√ √
low low low
ds-DFSA [13]
√
difficult
√ √
high low low
BS [10]
√
easy × × medium high low
ABS [9]
√
easy × × medium high low
ABTSA [23]
√
difficult
√ √
high high high
a large M may cause too many idle slots. In our proposed
algorithm, we define such a result with a large number of idle
slots as over-splitting.
B. The proposed FSA-CSS algorithm
According to the analysis above, the FS mechanism can
accelerate the splitting speed and reduce collision during the
identification process. However, the question is how to apply
the FS mechanism and avoid over-splitting, given the number
of tags is unknown at the beginning? To tackle the over-
splitting problem, we propose the fast splitting algorithm
with consecutive slot status detection (FSA-CSS). The main
idea is that the reader implements the FS mechanism only
when it detects a consecutive collision. The consecutive col-
lision indicates a large number of tags coexist in the same
identification process. In contrast, when the reader detects a
consecutive idle, it performs the shrink mechanism by sending
a Decrease command to decrease counter value of tags. The
shrink mechanism is defined as follows.
T
c
= trunk (T
c
/2) . (3)
where trunk() is a truncation function. The flowchart of the
proposed FSA-CSS algorithm is illustrated in Fig. 2. Two
thresholds µ and σ are denoted as the upper tolerance limit
of the number of consecutive collision slots and idle slots,
respectively, and two counters T
CCN
and T
CIN
are used at
the reader to count the number of consecutive collision slots
and idle slots. If T
CCN
≥ µ, the reader should perform the
FS mechanism. If T
CIN
≥ σ, the reader should perform the
shrink mechanism due to the occurrence of over-splitting.
As can be observed in Fig. 2, the reader sends the cor-
responding feedback commands according to the slot type.
Similar to BS, the reader also has a counter R
c
to terminate
the identification process when R
c
< 0. By receiving feedback
commands from the reader, each tag acts as follows.
• Splitting 0 command: Tags with T
c
= 0 act T
c
= T
R
,
while tags with T
c
>0 act T
c
= T
c
+ 1. It is similar to the
ID-collision feedback of the BS algorithm. After
sending this command, the reader acts R
c
=R
c
+1.
• Splitting 1 command: Tags with T
c
= 1 act T
c
= T
R
.
Tags with T
c
>0 will be split into two groups. The
potential advantage is to reduce the collisions.
• Increase command: All tags act T
c
= 2·T
c
+T
R
. Beside
the current collided tags, tags with T
c
>0 will be divided
after receiving this command. This is essentially different
to the BS algorithm. After sending this command, the
reader acts R
c
=2· R
c
+1.
• Decrease command: All tags act T
c
= trunk(T
c
/2).
This command is allowed to alleviate the over-splitting.
After sending this command, the reader acts R
c
=
round(R
c
/2).
• QueryRep command: All tags act T
c
= T
c
− 1. This is
similar to the ID-idle and ID-success of the BS
algorithm. After sending this command, the reader acts
R
c
=R
c
-1.
It is worth noting that the optimal M cannot be directly de-
rived by the algorithm. In this paper, we choose an appropriate
value M by using experimental method. Intuitively, a larger M
can provide more splitting subsets and hence reduce collisions.
However, it also introduces idle slots. In our proposed solution,
we choose M = N = 2 to best achieve the simplicity and
balance between the performance and complexity of using
random number generator by each tag. Additional analysis
and discussion can be found from Section IV and Fig. 3
which compares the number of slots consumed by FSA-CSS
by adopting different M .
Fig. 4 illustrates an example of seven tags by implementing
the proposed FSA-CSS algorithm. Assume µ = 3 and σ = 3,
the reader performs the FS mechanism in the slot 3 due to
T
CCN
= 3. Then the reader performs the BS in each tag
subset. After the tag c is identified, three consecutive idle
slots occur, the reader performs the shrink mechanism in slot
11 to decrease the counter value of unidentified tags in order
to alleviate over-splitting. Thereafter, the tags g, e and f are
identified in slot 13, slot 15 and slot 16, respectively. The
detailed communication procedure is also illustrated in Tab.
II. In essence, compared to the conventional BS algorithm,
the proposed FSA-CSS algorithm can reduce collisions but
introduce extra idle slots. However, the FSA-CSS can use the
Increase command to alleviate the negative impact from the
idle slots.
C. Upper bound performance of FSA-CSS
In this section, we analyze the system throughput of FSA-
CSS. The system throughput T
sy s
is defined as follows
T
sy s
=
m
N
m
. (4)
where m is the number of tags waiting to be identified in the
reader vicinity, N
m
is the required total slots to identify the
m tags. The system throughput is actually equivalent to the
