A Filter-Based and Parallel Unknown Tag Identification Protocol in Open RFID Systems

Abstract

Unknown tag identification plays a pivotal role in radio frequency identification (RFID) systems, but it has not been fully investigated. This paper proposes a filter-based and parallel unknown tag identification protocol (FPUI) for open RFID systems. The FPUI adopts an RSQF-based fingerprint filter to reconcile the collision slots and discriminate the known tags from unknown tags. Meanwhile, it collects the IDs of unknown tags in parallel. FPUI achieves high performance through the following three steps: (1) adopting the RSQF-based filter to build an indicator vector, thus improving the space efficiency; (2) building a fingerprint filter to discriminate known tags from unknown tags, thus reducing the false positive rate; (3) employing a parallel identification scheme to collect the IDs of unknown tags, thus improving identification efficiency. The identification time of our protocol was minimized by conducting a theoretical analysis of the relevant parameters. Furthermore, the performance of our protocol was evaluated by conducting a wide range of simulation experiments. The theoretical analysis and simulation results indicated that our protocol significantly outperformed the current advanced protocols.

1. Introduction

Radio frequency identification (RFID) has a variety of applications in the Internet of Things, such as supply chain management [1,2,3,4,5], warehouse inventory [6,7,8,9,10], object monitoring and tracking [11,12,13,14,15], and posture recognition and localization [16,17,18,19,20]. In this broad range of RFID-enabled applications, unknown tag identification is crucial for collecting tag IDs from unexpected tags. For example, when a group of tagged objects is moved into a supermarket or warehouse such as Walmart, the manager needs to store these new tag IDs in the back-end database server for subsequent business operations such as daily inventory. In another example of a shopping mall, the customers often misplace frozen food with candy, causing the food to rot, or misplace oil near a lighter, causing great danger. The objective of unknown tag identification is to quickly identify newly added or misplaced tags from a large number of known tags. Considering a large-scale RFID system with millions of known tags whose IDs have already been stored in the back-end database previously, these known tags will participate in the identification of unknown tags, thus making it difficult to identify the unknown tags rapidly.

The existing unknown tag identification protocols are divided into two categories: probabilistic protocols [21,22,23] and deterministic protocols [24,25,26,27,28]. The probabilistic protocols can perform unknown tag detection quickly with an expected accuracy. The state-of-the-art probabilistic protocol is the collision seeking detection (CSD) protocol [23], which finds a collision seed to make many known tags collide in the last N slots with a frame size of f, thus saving the detection time and ensuring the desired detection accuracy. The deterministic protocol can correctly identify all unknown tags in a batch. Reference [25] proposed a series of protocols to improve identification performance. The basic unknown tag identification protocol (BUIP) separates known tags from unknown tags and deactivates them; the single-pairing unknown tag identification protocol (SUIP) adopts a slot pairing method, and the multi-pairing unknown tag identification protocol (MUIP) adopts multiple reselection methods to resolve the problem of known tag collisions. Meanwhile, the filtering-based unknown tag identification protocol (FUTI) and the interactive filtering-based unknown tag identification protocol (IFUTI) were investigated in [27] to separate unknown tags from known tags and assign a status code to each singleton slot, thus reducing known–unknown collisions and identifying unknown tags at the bit level. Although the existing protocols can identify unknown tags, they do not have enough time efficiency and space efficiency in open RFID systems.

This paper investigates the problem of unknown tag identification in open RFID systems and proposes a deterministic unknown tag identification protocol called the filter-based and parallel unknown tag identification (FPUI) protocol. Considering the drawbacks of the existing protocols, the proposed protocol formulates a solution that satisfies the requirements of efficiency and accuracy by: (1) taking less time and space to achieve unknown tag identification; (2) accurately collecting the information of unknown tags. To achieve these goals, the FPUI consists of two phases: the separation phase and the collection phase. In the first phase, the FPUI adopts an RSQF-based filter [29] to calculate the hash value for each known tag by $H(·)$ and divides the hash value into two parts: $quotient$ and $remainder$. The $remainders$ of tags with an identical $quotient$ are placed in consecutive slots from small to large, and this sequence of slots is called a $run$. Meanwhile, the fingerprint filter assigns different fingerprints to multiple known tags in the same $run$ to reconcile the collision slots and separate the known tags from unknown tags. In the second phase, the FPUI collects the IDs of multiple tags by using a CDMA-based parallel identification method.

The main contributions of this paper are summarized as follows:

(1) A complete and robust solution to unknown tag identification in open RFID systems is provided.

(2) An RSQF-based fingerprint filter is utilized to solve the problem of slot collisions and separate the known tags from unknown tags, thus improving slot utilization and reducing the false positive rate.

(3) A parallel identification method is adopted to collect the IDs of multiple unknown tags with high efficiency.

(4) The performance of the proposed protocol is formally analyzed. The impact of various parameters on the identification time of our protocol is investigated, and the parameters are optimized to obtain the shortest identification time.

(5) Theoretical analysis and extensive simulations are conducted. The results indicate that our protocol performs better and has a lower false positive rate than the existing advanced protocols.

The rest of the paper is organized as follows. Section 2 introduces the related work. Section 3 formulates our problem. Section 4 proposes an efficient and complete unknown tag identification protocol called FPUI and theoretically analyzes its performance. Section 6 evaluates our protocol. Section 7 summarizes this paper.

2. Related Work

Many recent studies on RFID technology focus on functional applications, including information collection [30,31], cardinality estimation [32,33], tag grouping [34,35], searching a wanted tag set [36,37], and missing tag identification [38,39]. Unknown tag identification, as a research branch, is practically important because it helps identify the unknown tags that are misplaced or moved in the reader’s interrogation area. To solve this problem, two categories of protocols have been designed: the probabilistic protocol [21,22,23] and the deterministic protocol [24,25,26,27,28].

The probabilistic protocol can identify unknown tags rapidly with an expected accuracy. Liu et al. designed an unknown tag detection scheme for detecting unknown tags with an expected confidence level [21]. Gong et al. proposed the white paper (WP) protocol [22], which constructs a composite message data structure consisting of all useful informative data from some independent detection synopses. This structure helps improve the unknown tag detection efficiency and decrease the failure probability. Although these probabilistic protocols can judge unknown tags in a fast way, they cannot identify the information of all unknown tags’ IDs. Compared with the probabilistic protocol for unknown tag identification, the deterministic protocol can collect all information of unknown tags’ IDs. For example, Sheng et al. firstly formulated the problem of unknown tag identification and presented an unknown tag identification protocol called continuous scanning (CU), which can collect a specified fraction of intact unknown tags [24]. However, CU only achieves incomplete unknown tag identification caused by randomized algorithms. Liu et al. proposed the BUIP, SUIP, and MUIP protocols [25], which adopt indicator vectors to distinguish known tags from unknown tags and deactivate the known tags. Although they can identify the intact unknown tag set with higher efficiency, more time is needed. Liu et al. proposed the FUTI and IFUTI protocols [27], which investigate the interactive filters to accelerate the process of unknown tag identification. Xie et al. proposed the unknown tag identification protocol based on a coded filtering vector [26], which utilizes the coded filtering vector technique to separate unknown tags from known tags and assign each singleton slot a status code to reduce known–unknown collisions, thus improving the identification performance. Zhu et al. proposed the physical-layer unknown tag identification (PUTI) protocol [28], which identifies the unknown tags by aggregating physical layer signals. Although these deterministic protocols can identify unknown tags, they are time-consuming and suffer from a high false positive rate.

This paper proposes a filter-based and parallel unknown tag identification protocol called FPUI. The FPUI thoroughly separates known tags from unknown tags and deactivates all known tags by adopting an RSQF-based fingerprint filter, thus improving the slot utilization and the accuracy of the protocol. Meanwhile, the FPUI adopts a parallel identification method to collect multiple unknown tag IDs in parallel, thus increasing the efficiency of the protocol.

3. System Model

3.1. Assumption and Problem

This paper considered an open RFID system consisting of one reader, N known tags, M unknown tags, and some missing tags. All these tags were within the interrogating range of this reader. The IDs of all known tags (including missing tags) were already stored in the back-end database of the server, but all IDs and M unknown tags were unavailable in the server. The known tag set is denoted as $\mathbb{K}$, i.e., $\mathbb{K}=\{t_1,t_2,\cdots ,t_i,\cdots ,t_N\}$, and the unknown tag set is denoted as $\mathbb{U}$, i.e., $\mathbb{U}=\{t_{u_1},t_{u_2},\cdots ,t_{u_i},\cdots ,t_{u_M}\}$. The intersection of sets $\mathbb{K}$ and $\mathbb{U}$ is null, i.e., $\mathbb{K}\cap \mathbb{U}=\varnothing$. Each tag has a unique ID, and all tags are equipped with the identical hash generator $H(·)$. The missing tag set is a part of the known tag set $\mathbb{K}$. Figure 1 presents an overview of an open RFID system with unknown tags and missing tags. There are a large number of known tags and numerous unknown tags in the interrogation of the reader.

Table 1. Notations.

Symbols	Descriptions
$\mathbb{\hspace{1em}\hspace{1em}\hspace{1em}K\hspace{1em}\hspace{1em}\hspace{1em}}$	A known tag set
$\mathbb{\hspace{1em}\hspace{1em}\hspace{1em}U\hspace{1em}\hspace{1em}\hspace{1em}}$	An unknown tag set
N	The number of known tags
M	The number of unknown tags
$\hspace{1em}\hspace{1em}\hspace{1em}{l}_{fp}\hspace{1em}\hspace{1em}\hspace{1em}$	The size of the fingerprint
$\hspace{1em}\hspace{1em}\hspace{1em}{F}_R\hspace{1em}\hspace{1em}\hspace{1em}$	A real frame in the collection phase
$\hspace{1em}\hspace{1em}\hspace{1em}{V}_C\hspace{1em}\hspace{1em}\hspace{1em}$	An address code vector
$\hspace{1em}\hspace{1em}\hspace{1em}{l}_s\hspace{1em}\hspace{1em}\hspace{1em}$	The size of the address code vector
m	The size of the address code
n	The number of missing tags
$\hspace{1em}\hspace{1em}\hspace{1em}H(·)\hspace{1em}\hspace{1em}\hspace{1em}$	A hash function with a uniform random distribution

shows the notations used in this paper. The objective of our protocol is to collect the information of the intact IDs of all unknown tags from the total tag set $\mathbb{K}\cup \mathbb{U}$ and eliminate the influence of false positives.

3.2. Communication Slots

The physical-layer RFID communication between the reader and the tags was based on slotted ALOHA. The reader starts a slotted frame, on the basis of which each tag randomly maps itself to one of the slots by a hash function. Thus, there are three categories of slots: (1) empty slot: selected by no tags; (2) singleton slot: selected by just one tag; (3) collision slot: selected by more than one tag. In this paper, singleton slots and collision slots are also called non-empty slots. By constructing the frame and handling the statuses of slots, the reader can accumulate the functional information of the expected tags for the practical application of RFID systems.

To distinguish an empty slot from non-empty slots, the tag needs to transmit only 1 bit of information, which needs $t_s$ time in a slot. Meanwhile, it takes $t_l$ time in a slot to transmit 10 bits of information for distinguishing the three types of slots. The time for transmitting one tag ID (96 bits) from the tag to the reader is denoted by $t_{tag}$. Generally, $t_{tag}>t_l>t_s$.

4. Filter-Based and Parallel Unknown Tag Identification Protocol

In this section, the filter-based and parallel unknown tag identification (FPUI) protocol is proposed, which can identify all unknown tags within the interrogation area efficiently and completely.

4.1. Basic Idea

Most of the existing unknown tag identification protocols are based on a slotted hash, and they have two drawbacks: large time consumption and low accuracy. Firstly, the existing protocols have lower slot utilization due to slot collisions. In this case, they need multiple rounds to deactivate all known tags, which is time-consuming. Secondly, a false positive occurs when an unknown tag and a known tag pick the same slot, resulting in this unknown tag being deactivated.

The idea of the FPUI is to identify unknown tags as quickly and precisely as possible by the following three design principles:

(1) Improving slot utilization: In the slotted-ALOHA-based protocol, multiple tags may choose a slot to respond to the reader, causing slot collisions and reducing slot utilization. This protocol modifies the RSQF filter to reconcile the collision slots to single slots, thus increasing the number of useful slots.

(2) Eliminating false positives: In real open RFID systems, unknown tags may select the same slot as known tags, which causes these unknown tags to be regarded as known tags and deactivated, i.e., a false positive problem. The key to tackling the problem is separating known tags from unknown tags thoroughly. In this paper, a unique fingerprint is provided for each known tag in a $run$ to distinguish known tags from unknown tags, thus eliminating false positives.

(3) Increasing the identification efficiency: Traditional tag identification protocols adopt ALOHA-based or tree-based methods to collect the tag ID information serially, so the process is time-consuming. This paper proposes a parallel tag ID collection scheme to concurrently identify multiple unknown tags, thus increasing the identification efficiency.

To achieve the above goals, the FPUI identifies unknown tags in two phases: the separation phase and the collection phase. In the first phase, an RSQF-based fingerprint filter is built to separate known tags from unknown tags. In the second phase, the IDs of unknown tags are concurrently collected by assigning a series of orthogonal address codes to multiple singleton unknown tags, which is similar to CDMA technology.

4.2. Separation Phase

In this phase, the reader first builds an RSQF-based filter to increase the number of useful slots. Then, the reader constructs a fingerprint filter to separate known tags from unknown tags. The process of the separation phase is described in detail below.

4.2.1. Building an RSQF-Based Filter

The reader first calculates the hash value for each known tag by $H(id,r_1)$, where $id$ is the tag’s ID and $r_1$ is a random seed. The RSQF filter divides $H(id,r_1)$ into two parts: the first q-bit part is called $quotient$, denoted by $h_0\left(id\right)$, and the second r-bit part is called $remainder$, denoted by $h_1\left(id\right)$. In this paper, the original RSQF filter was modified to make it adapt to our problem. The modified RSQF-based filter maintains a vector $occupieds$ to determine whether a slot is occupied or not. A position j is occupied and is set to “1” when there is at least one tag $t_i$ whose $h_0\left(i{d}_i\right)=j$. The number of “1s” in the $occupied$ vector up to position j is counted as $s_j$, and the total number of “1s” in the $occupieds$ vector is counted as s. Furthermore, the RSQF-based filter maintains a vector Q in which there are N slots. Each slot with a size of r bits can store a $remainder$. The $remainders$ of tags with an identical $quotient$ are placed in consecutive slots from small to large. In this paper, this sequence of slots is called a $run$, and the number of tags in a $run$ is called the $runsize$. When a tag $t_i$ is inserted, the RSQF-based filter tries to store its $remainder$$h_1\left(i{d}_i\right)$ in the $home$$slot$$Q\left[s_{h_0\left(i{d}_i\right)}\right]$. Here, the linear probing scheme was adopted to store the $remainders$ in the same $run$. As will be described below, the RSQF-based filter seeks out an unoccupied slot to save $h_1\left(i{d}_i\right)$ when its $home$$slot$ is already occupied.

A slot storing a $remainder$ is called “used”, and a slot storing no $remainder$ is called “unused”. Since the RSQF-based filter uses the linear probing scheme to store $remainders$, a slot may also be “used” even when its corresponding position in the $occupieds$ vector is not occupied. The RSQF-based filter always attempts to store the $remainders$ in their $home$$slots$ and only drifts a $remainder$ when its $home$$slot$ is occupied by another $remainder$. As shown in Figure 2, the RSQF-based filter maintains three vectors to determine whether a slot is “used” or not and the actual slot in which each $remainder$ is stored. Specifically, the $occupieds$ bit vector with a size of $2^q$ is used to indicate the $home$$slot$ of each tag, the $runends$ bit vector with a size of N is used to indicate the number of tags having the same $home$$slot$, and the $remainders$ vector (namely Q array) is used to indicate the actual slot of each tag.

For the convenience of expression, two operations are defined for the RSQF-based filter: $SELECT(·)$ and $RANK(·)$. For a given bit vector D, $SELECT(D,i)$ returns the index of the ith 1 in D, and $RANK(D,i)$ returns the number of 1s preceding the ith position in D, i.e., $RANK(D,i)={\Sigma }_{j=0}^{i-1}D\left[j\right]$. The two operations help seek out the $run$ of any $quotient$$h_0\left(id\right)$. If $occupieds\left[h_0\left(id\right)\right]=0$, there is no such $run$; otherwise, $RANK(occupieds,h_0\left(id\right))$ is applied to calculate the number $s_j$ of slots $j\le h_0\left(id\right)$, i.e., the number of $runs$ preceding the slot $h_0\left(id\right)$, and then, $SELECT(runends,s_j+1)$ is applied to calculate the end position of the $s_j$th $run$. As shown in Figure 2, the slot of tag $t_i$ is in the $\left\{{\lambda }_i\right\}$th $run$, where ${\lambda }_i=s_{h_0\left(i{d}_i\right)}=RANK(occupieds,h_0\left(i{d}_i\right))$. The end slot of this $run$ is $e_{{\lambda }_i}=SELECT(runends,{\lambda }_i+1)$, and the beginning slot of this $run$ is $b_{{\lambda }_i}=SELECT(runends,{\lambda }_i)+1$ (we set $SELECT(runends,0)$ to be $-1$). Thus, the size of this $run$ can be obtained by $runsiz{e}_{{\lambda }_i}=e_{{\lambda }_i}-b_{{\lambda }_i}+1$. The actual slot index of tag $t_i$ falls between $b_{{\lambda }_i}$ and $e_{{\lambda }_i}$. The tag $t_i$ checks the jth position in the $remainders$ vector ($b_{{\lambda }_i}\le j\le e_{{\lambda }_i}$). When $remainders\left[j\right]>h_1\left(i{d}_i\right)$ and $remainders[j-1]\le h_1\left(i{d}_i\right)$, $t_i$ is inserted $h_1\left(i{d}_i\right)$ into the jth position.

4.2.2. Building Fingerprint Filter

Although the RSQF-based filter can assign a slot to each known tag, it cannot solve the slot collision problem when multiple tags have the same $quotient$ and $remainder$. Furthermore, it cannot separate known tags from unknown tags with the same $quotient$ and $remainder$ in open RFID systems. Therefore, this paper added a $fingerprints$ vector to solve the above two problems. The reader generates a unique $l_{fp}$-bit fingerprint via a hash function $h_2(id,r_2)$ for every tag in the same $run$, where $r_2$ is another random seed. The reader inserts the fingerprint of each tag into the corresponding position of the $fingerprints$ vector according to the $remainders$ vector, as shown in Figure 2.

The reader broadcasts a request with parameters $\langle occupieds,runends,fingerprints,r_1,r_2\rangle$ to all tags. After receiving the request, the tag $t_i$ firstly calculates its occupieds index by $h_0\left(i{d}_i\right)$ and obtains its $run$ index ${\lambda }_i$. Then, it obtains the beginning position $b_{{\lambda }_i}$ and the end position $e_{{\lambda }_i}$ in the $fingerprints$ vector. Subsequently, it calculates its fingerprint $F{P}_i$ by $h_2(i{d}_i,r_2)$ and checks $fingerprints\left[j\right]$ ($b_{{\lambda }_i}\le j\le e_{{\lambda }_i}$). If $F{P}_i=fingerprints\left[j\right]$, this tag regards itself as a known tag and deactivates itself. The flowchart of separation phase is shown in Figure 3. After this phase, all known tags are deactivated without participating in the collection phase.

4.3. Collection Phase

In this phase, our objective was to efficiently collect the IDs from all unknown tags. To save the collection time, the IDs were collected concurrently from multiple singleton unknown tags through a CDMA-based method, and each tag needs to determine its address code before transmitting its ID to the reader. The accomplishment of this goal involves four stages.

4.3.1. Building Real Frame

The real frame is constructed based on the responses of all unknown tags. In particular, the reader broadcasts a request with the parameter $\langle f,r_3\rangle$ to issue the frame, where f is the size of the real frame and $r_3$ is a random seed. In this frame, each active unknown tag $t_{u_i}$ randomly picks a slot by the hash function $H(i{d}_{u_i},r_3)$$mod$ f and sends a 1-bit response to the reader in this slot. The reader listens to the channel and records the status of each slot, i.e., empty and collision are recorded as “0” and singleton is recorded as “1”. Then, the reader obtains the real frame that reflects the actual responses from the unknown tags, and the frame is denoted by $F_R$. $F_R$ is also referred to as the indicator vector, and its length is f.

$$F_R\left[i\right]=\left\{\begin{array}{cc}0,\hfill & \mathrm{t}\mathrm{h}\mathrm{e}i\mathrm{t}\mathrm{h}\mathrm{s}\mathrm{l}\mathrm{o}\mathrm{t}\mathrm{i}\mathrm{s}\mathrm{a}\mathrm{n}\mathrm{e}\mathrm{m}\mathrm{p}\mathrm{t}\mathrm{y}\mathrm{/}\mathrm{c}\mathrm{o}\mathrm{l}\mathrm{l}\mathrm{i}\mathrm{s}\mathrm{i}\mathrm{o}\mathrm{n}\mathrm{s}\mathrm{l}\mathrm{o}\mathrm{t},\hfill \\ 1,\hfill & \mathrm{t}\mathrm{h}\mathrm{e}i\mathrm{t}\mathrm{h}slotisasingletonslot.\hfill \end{array}\right.$$

For example, as shown in Figure 4, there are 10 unknown tags $\{t_{u_1},t_{u_2},\cdots ,t{u}_{10}\}$ and $f=10$. The tags $\{t_{u_1},t_{u_3},t_{u_4},t_{u_6},t_{u_8}\}$ are mapped to the 1st, 3nd, 6th, 5th, and 10th singleton slots, respectively, and other tags are mapped to collision slots. Therefore, the real frame (also called the indicator vector) is denoted as “1010110001”.

4.3.2. Building Address Code Vector

The reader generates a series of orthogonal address codes and builds the address code vector $V_C$ with a length of $l_s$, where $l_s$ is the number of “1s” in $F_R$. Here, the $\mathit{Walsh}$ sequence is employed to provide address codes. The $\mathit{Walsh}$ sequence of order m can provide m different orthogonal address codes, and each address code is m bits long, which guarantees that m singleton unknown tags can respond in parallel. Every m singleton slot belongs to a $loop$. The address codes of all tags are different and orthogonal within a $loop$. Therefore, $V_C$ can be expressed as $\{a{c}_1,a{c}_2,\cdots ,a{c}_m,a{c}_1,a{c}_2,\cdots a{c}_m,\cdots \}$, where $a{c}_i$ is the address code of the tag $t_{u_i}$.

Taking Figure 4 as an example, the reader generates four orthogonal address codes and builds the address code vector $V_C$$\{1111,1010,1001,1100,1111\}$.

4.3.3. Assigning Address Code

The reader broadcasts the request with parameters $\langle F_R,V_C\rangle$ to all tags. Upon receiving the request, each singleton tag obtains its address code. Specifically, if the tag $t_{u_i}$ is mapped to the jth slot and $F_R\left[j\right]=1$, the address code of the tag is $V_C\left[{\mu }_i\right]$, where ${\mu }_i$ is the number of “1s” preceding the jth element in $F_R$. As shown in Figure 4, after receiving $F_R$ and $V_C$, each tag checks its index and obtains its address code. For example, the indexes of $\{t_{u_1},t_{u_3},t_{u_4},t_{u_6},t_{u_8}\}$ are $\{1,2,4,3,5\}$, and the corresponding address codes are “1111”, “1010”, “1100”, “1001”, and “1111”, respectively. So far, each singleton tag has an address code, which is different and orthogonal to the address codes of other singleton tags in its $loop$.

4.3.4. Collecting IDs in Parallel

The reader broadcasts the request to issue the frame. Every m unknown tag sends its ID to the reader in the same slot. For an arbitrary unknown tag $t_{ui}$, it adopts the following encoding scheme in place of $\mathit{FM}\mathit{0}$ and $\mathit{Miller}$.: (i) The tag transmits the true code of $V_C\left[{\mu }_i\right]$ in the $\lceil \frac{{\mu }_i}{m}\rceil$th slot if a bit of its ID is “1”.

(ii) The tag transmits the ones’ complement code of $V_C\left[{\mu }_i\right]$ in the $\lceil \frac{{\mu }_i}{m}\rceil$th slot if a bit of its ID is “0”.

Following the above rules, the number of real slots in the frame is $\lceil \frac{l_s}{m}\rceil$. Considering the address code “1010” of $t_{ui}$, the tag traverses each binary bit of its ID. In the ID, each “0” bit in the ID is encoded by “0101”, and each “1” bit is encoded by “1010”; they are transmitted in the $\lceil \frac{{\mu }_i}{m}\rceil$th slot. Upon receiving the overlapping information, the reader isolates each ID of the tag by calculating normalized inner products of each m code and the address code of this tag. If the normalized inner product is “1”, the bit received from this tag is “1”; if the normalized inner product is “−1”, the bit received from this tag is “0”; otherwise, this tag did not send information.

Take Figure 5 for example. The tags $\{t_{u_1},t_{u_3},t_{u_4},t_{u_6}\}$ concurrently transmit their IDs in the 1st slot. The first two bits in the IDs of $\{t_{u_1},t_{u_3},t_{u_4},t_{u_6}\}$ are $\{10,11,10,00\}$. According to the rules (i) and (ii), the bits “1” and “0” are encoded by the true code and the one’ -complement code of each tag’s address code, respectively. Using “−1” to represent “0” and “+1” to represent “1”, $t_{u_1}$ transmits $\left\{\right(+1,+1,+1,+1)$, $(-1,-1,-1,-1)\}$, $t_{u_3}$ transmits $\left\{\right(+1,-1,+1,-1)$, $(+1,-1,+1,-1)\}$, $t_{u_4}$ transmits $\left\{\right(+1,+1,-1,-1)$, $(-1,-1,+1,+1)\}$, and $t_{u_6}$ transmits $\left\{\right(-1,+1,+1,-1)$, $(-1,+1,+1,-1)\}$ in the first slot. Therefore, the reader receives the final overlapping information $\left\{\right(+2,+2,+2,-2),(-2,-2,+2,-2\left)\right\}$. The normalized inner product of the overlapping code and the address code determine whether a tag has sent data and what data to be sent. For example, the normalized inner product of $(+2,+2,+2,-2)$ and $(+1,+1,+1,+1)$ is “1”, which indicates that the first bit $t_{u_1}$ sent is “1”; the normalized inner product of $(-2,-2,+2,-2)$ and $(+1,+1,+1,+1)$ is “−1”, which indicates that the second bit $t_{u_1}$ sent is “0”. Consequently, the reader knows that the first two bits of $t_{u_1}$’s ID are “10”. Similarly, the reader can obtain the IDs of the other three tags.

If $F_R\left[i\right]=0$, the unknown tags picking this slot will participate in the next round. Then, the collection phase will be executed for several rounds until the reader cannot detect replies from unknown tags in the channel.

5. Performance Analysis

5.1. Fingerprint Size

First, the influence of fingerprint size $l_{fp}$ is discussed. In our filter, each tag has a unique fingerprint in its $run$. To achieve a higher separation accuracy, different hash functions can be chosen for each $run$ by transmitting multiple random seeds to tags. For saving the communication overhead, the fingerprint size was set to $\lceil lo{g}_{2}runsize\rceil$ for each $run$. To simplify the calculation, $l_{fp}$ is defined as the average fingerprint size, and it is discussed below. The probability $p_u$ of a slot not being occupied in the $occupieds$ vector is:

$$\begin{array}{c}\hfill p_u={(1-\frac{1}{2^q})}^N=e^{-{\rho }_1},\end{array}$$

(1)

where ${\rho }_1$ is $\frac{N}{2^q}$. The number $n_o$ of occupied slots in the $occupieds$ vector is:

$$\begin{array}{c}\hfill n_o=2^q(1-e^{-{\rho }_1}).\end{array}$$

(2)

Therefore, the average $runsize$ can be calculated as:

$$\begin{array}{c}\hfill runsiz{e}_{average}=\frac{N}{n_o}=\frac{N}{2^q(1-e^{-{\rho }_1})}=\frac{{\rho }_1}{(1-e^{-{\rho }_1})}.\end{array}$$

(3)

The average fingerprint is:

$$\begin{array}{c}\hfill l_{fp}=\lceil lo{g}_{2}runsiz{e}_{average}\rceil =\lceil lo{g}_2\frac{{\rho }_1}{(1-e^{-{\rho }_1})}\rceil .\end{array}$$

(4)

5.2. Address Code Size

Next, the influence of the address code size m on the execution time is discussed. The CDMA-based scheme has high noise resistance and application adaptability. This paper chose the $\mathit{Walsh}$ codes as the address codes of unknown tags, which can provide perfect orthogonal codes for concurrently identifying multiple unknown tags. However, the quality of communication may decrease when the address code size is large. Therefore, the $\mathit{Walsh}$ codes with an order of 4∼64 were adopted to guarantee the communication quality, which indicates that $4\le m\le 64$.

According to the characteristics of the $\mathit{CDMA}$ code, there are $\frac{m}{2}$ sub-carrier cycles per symbol after modulation, so the data rate is $2BLF/m$, which indicates that the data rate is in an inverse proportion to m. That is, the performance of the protocol will decrease as m increases. Letting $t_{tag}$ be the time for transmitting a 96-bit ID from the tag to the reader based on the $\mathit{FM}\mathit{0}$ code, we have $t_{tag}^{\prime }=\frac{m{t}_{tag}}{2}$. In our protocol, $m=4$.

5.3. Time Efficiency

In this section, the time efficiency of the FPUI protocol is analyzed. The execution time comprises two parts: the separation time and the collection time. The total execution time is given as:

$$T_t=T_{sep}+T_{col},$$

(5)

where $T_{sep}$ is the separation time and $T_{col}$ is the collection time. The separation time $T_{sep}$ is represented as:

$$\begin{array}{cc}\hfill T_{sep}& =\frac{2^q+N\times (l_{fp}+1)}{96}\times t_{id}\hfill \\ \hfill & =(2^q+(l_{fp}+1)N)\frac{t_{id}}{96},\hfill \end{array}$$

(6)

where $t_{id}$ is the time for transmitting 96-bit information from the reader to the tags, q is the size of $quotient$, N is the number of known tags, and $l_{fp}$ is the average length of the fingerprint. The number $\eta$ of bits per tag is defined as:

$$\begin{array}{cc}\hfill \eta & =\frac{2^q}{N}+(l_{fp}+1)\hfill \\ \hfill & =\frac{1}{{\rho }_1}+\lceil lo{g}_2\frac{{\rho }_1}{(1-e^{-{\rho }_1})}\rceil +1.\hfill \end{array}$$

(7)

$\eta$ is minimized to obtain the optimal space efficiency. Then, the optimal parameter ${\rho }_1$ for minimizing $\eta$ is investigated. The derivative of $\eta$ can be given as follows:

$$\begin{array}{cc}\hfill \frac{\partial \eta }{\partial {\rho }_1}& =-\frac{1}{{\rho }_1^2}+\frac{1}{{\rho }_{1}ln2}-\frac{e^{-{\rho }_1}}{(1-e^{-{\rho }_1})ln2}.\hfill \end{array}$$

(8)

By setting the derivatives in Equation (8) to 0, the lowest space efficiency is obtained when ${\rho }_1$ is $1.3$. Then, the reader takes 1.93 bits to deactivate one known tag and the average fingerprint $l_{fp}=2$. Figure 6a shows the changes of unit execution time $\delta$ with respect to $\rho$. Therefore, the minimum separation time is:

$$\begin{array}{c}\hfill T_{sep}^{min}=\frac{1.93t_{id}}{96}N\mathrm{ms}=0.02N{t}_{id}\mathrm{ms}.\end{array}$$

(9)

Then, the collection time $T_{col}$ is discussed. Considering the ith round of unknown tag IDs’ collection, the collection time, denoted by $T_{col}^i$, is expressed as follows:

$$\begin{array}{c}\hfill T_{col}^i=M_i\times t_s+\frac{f_i+l_s^i\times m}{96}\times t_{id}+\lceil \frac{l_s^i}{m}\rceil \times t_{tag}^{\prime },\end{array}$$

(10)

where $M_i$, $f_i$, and $l_s^i$ are the number of participating unknown tags, the frame size, and the number of singleton slots in the ith round, respectively; $t_s$ is the time for the tag transmitting 1 bit of information to the reader; $t_{tag}^{\prime }$ is the time for transmitting a 96-bit ID from the tag to the reader. Note that $t_{id}$ and $t_s$ were based on the traditional $\mathit{FM}\mathit{0}$ code, and $t_{tag}^{\prime }$ was based on the $\mathit{CDMA}$ code. The probability of mapping one unknown tag to a singleton slot in this round is denoted as $P_s^i$, which is given as follows:

$$\begin{array}{cc}\hfill P_s^i& =M_i\times \frac{1}{f_i}\times {(1-\frac{1}{f_i})}^{M_i-1}\hfill \\ \hfill & =\rho e^{-\rho },\hfill \end{array}$$

(11)

where $\rho =\frac{M_i}{f_i}$. Therefore, $l_s^i=f_i\times \rho e^{-\rho }$. This paper defines the unit collection time $\delta$ as the ratio of the collection time to the number of identified tags in the ith round. Therefore, we have:

$$\begin{array}{cc}\hfill \delta & =\frac{M_i\times t_s+\frac{f_i+f_i\rho e^{-\rho }m}{96}\times t_{id}+\lceil \frac{f_i\times \rho e^{-\rho }}{m}\rceil \times t_{tag}^{\prime }}{f_i\rho e^{-\rho }}\hfill \\ \hfill & \approx e^{\rho }{t}_s+(\frac{e^{\rho }}{\rho }+m)\frac{t_{id}}{96}+\frac{t_{tag}^{\prime }}{m}.\hfill \end{array}$$

(12)

Here, $\delta$ needs to be minimized to achieve the shortest collection time. Next, the optimal parameter $\rho$ is found to minimize $\delta$. The derivative of $\delta$ is calculated as follows:

$$\begin{array}{cc}\hfill \frac{\partial \delta }{\partial \rho }& =e^{\rho }{t}_s+\frac{e^{\rho }(\rho -1)}{{\rho }^2}\frac{t_{id}}{96}.\hfill \end{array}$$

(13)

Based on the Philips I-Code system [20] and the $\mathit{CDMA}$ code, we have $t_{id}=2.4$ ms, $t_{tag}=2.3$ ms, $t_l=0.8$ ms, and $t_s=0.4$ ms. By setting the derivative in Equation (13) to 0, the minimum unit collection time is obtained when $\rho$ is $0.22$. That is, the minimum execution time is taken to collect the IDs of all unknown tags when $f=4.5M$. Figure 6b shows the changes of unit execution time $\delta$ with respect to $\rho$. As a result, the optimal collection time $T_{col}^{op}$ can be given as follows:

$$\begin{array}{cc}\hfill T_{col}^{op}& =(0.51+0.03m+\frac{t_{tag}^{\prime }}{m})M\left(\mathrm{ms}\right)\hfill \\ \hfill & =(0.51+0.03m+\frac{t_{tag}}{2})M\left(\mathrm{ms}\right)\hfill \\ \hfill & =(1.66+0.03m)M\left(\mathrm{ms}\right).\hfill \end{array}$$

(14)

Substituting $t_{id}=2.4$ ms into (9), the optimal separation time can be given as follows:

$$\begin{array}{c}\hfill T_{sep}^{min}=0.02N{t}_{id}\mathrm{ms}=0.048N\mathrm{ms}.\end{array}$$

(15)

By substituting (14) and (15) into (5), the total execution time is $1.66M+0.03mM+0.048N$ ms.

5.4. Discussion on False Positive Rate

As shown in [29], the original RSQF filter takes $\frac{2.125+lo{g}_{2}1/\zeta }{\alpha }$ bits to count one element, where $\alpha$ is the load factor and $\zeta$ is the false positive rate. When the false positive rate is smaller than 1/64, the RSQF filter has better space efficiency than other classic filters, including the Bloom filter, the Cuckoo filter, and the original QF filter. The RSQF filter maintains a load factor of up to 0.95, and our filter has the same load factor as the original RSQF filter. Meanwhile, in the RSQF filter, multiple tags in a $run$ may have the same $remainder$; in our filter, due to the tags in a $run$ having different fingerprints, our filter has a better false positive rate than the original RSQF filter.

6. Evaluation

This section evaluates the performance of our protocol and the existing CU [24], BUIP and MUIP [25], and FUTI and IFUTI protocols [27]. Also, the execution time of our protocol is compared with that of state-of-the-art unknown identification protocols.

6.1. Simulation Setting

Our protocol was implemented in Matlab and run on a ThinkPad X1 Carbon desktop computer equipped with an Intel 2.40 GHz CPU. In the simulations, there was a 302 $\mathsf{\mu }$s interval between each pair of consecutive communications from the tag to the reader and from the reader to the tags. The transmission rates in different directions were not symmetric depending on specific physical implementations and practical environments. According to the specification of the Philips I-Code system [20] and the $\mathit{CDMA}$ code, we have $t_{id}=2.4$ ms, $t_{tag}=2.3$ ms, $t_l=0.8$ ms, $t_s=0.4$ ms, and $t_{tag}^{\prime }=1.15m$ ms. Our simulations were executed 100 times in Matlab, and the results were averaged.

6.2. Total Execution Time

In this section, the total execution time of our protocol is analyzed and the proposed FPUI protocol is compared with some state-of-the-art protocols, including CU, BUIP and MUIP, and FUTI and IFUTI. In different applications, the number of unknown tags also varies. Therefore, in the following simulation experiments, the number N of known tags was fixed to 10,000 and the number M of unknown tags was changed in different applications. To thoroughly evaluate the performance of our protocol, two sets of simulations were conducted under two application scenarios: the scenario of low-density unknown tags and the scenario of high-density unknown tags. Furthermore, a set of simulations was conducted to evaluate the impact of the size m of the address code on the execution time.

Low-density unknown tags scenario: In this scenario, a simulation was conducted for an RFID system under low-density unknown tags. Here, the number M of unknown tags varied from 100 to 1000 with a step of 100. As shown in Figure 7a, the simulation results demonstrated that our FPUI protocol outperformed the advanced protocols in [25,27]. Specifically, the took takes 5.6 s and MUIP 18.8 s to identify 200 unknown tags, respectively. By contrast, our proposed PFUI protocol just took 0.86 s to identify 200 unknown tags, showing 84.6% and 95.4% less execution time than the IFUTI and MUIP protocols, respectively.

High-density unknown tags scenario: In this scenario, a simulation was conducted for an RFID system under high-density unknown tags. Here, the number M of unknown tags varied from 5000 to 14,000 with a step of 1000. As shown in Figure 7b, the simulation results demonstrated that our FPUI protocol also performed better than the existing protocols in [25,27]. Concretely, the IFUTI protocol took 42.7 s and the MUIP protocol 107.9 s to identify 12,000 unknown tags, respectively. By contrast, our proposed FPUI protocol only took 31.9 to identify 12,000 unknown tags, showing 25.3% and 70.4% less execution time than the IFUTI and MUIP protocols, respectively.

The simulation results in

Table 2. Total execution time of the protocols, where N is fixed to 10,000.

Alg. Name	CU	BUIP	MUIP	FUTI	IFUTI	FUTI
$M=100$	46.3	22.7	17.6	4.2	3.9	0.71
$M=500$	50.2	25.7	21.4	6.4	4.9	1.4
$M=1000$	55.7	29.3	24.6	9.3	6.8	2.8
$M=5000$	95.2	61.8	55.9	35.7	21.2	13.3
M = 10,000	152.7	106.3	98.7	72.8	39.5	28.2

also show that our FPUI protocol was more efficient under the RFID scenario with low-density unknown tags and high-density unknown tags.

6.3. Impact of Address Code Variation

In this group of simulation experiments, the execution time of our protocol in an RFID system with different m values was evaluated. The size m of the address code was varied from 4 to 64 with a step of 2x. Meanwhile, The number M of unknown tags was changed from 1000 to 10,000 to observe the impact of m on the total execution time. As seen in Figure 8, the simulation results demonstrated that our FPUI protocol achieved the best performance when $m=4$. This is because, as m increased, the data rate decreased and the reader needed to transmit more information to the tags for their address codes. This analysis was consistent with that presented in Section 5.2.

6.4. Impact of Missing Tags

Since our protocol assigns a unique fingerprint to each known tag, all known tags can be deactivated to remove false positives. Then, a set of simulations was conducted to evaluate the impact of the number n of missing tags on the deactivating accuracy. As shown in Figure 9, our protocol always deactivated all known tags regardless of the number n of missing tags, which indicates that our protocol can achieve better performance in real open RFID systems than other existing works.

7. Conclusions

This paper investigated the problem of unknown tag identification in open RFID systems and proposed a filter-based parallel unknown tag identification protocol (FPUI), which can address the unknown tag identification problem completely and efficiently. FPUI first separates known tags from unknown tags by constructing an RSQF-based fingerprint filter, deactivating all known tags and eliminating false positives. Then, it effectively identifies unknown tags by using a CDMA-based parallel identification scheme. A theoretical analysis was conducted to optimize the parameters for minimizing the total execution time. Meanwhile, many simulation experiments were carried out to evaluate the performance of the proposed protocol. The simulation results indicated that the proposed protocol comparatively outperformed the existing advanced protocols.