Smart Batch-Processing Protocol for RFID Multiple Tag Identification

The common paradigm of the RFID network is to obtain data from multiple tags through a reader. The tag collision problem seriously affects the efficiency of tag identification. The anti-collision algorithm provides a reliable guarantee to identify multiple tags as fast as possible. Many papers have proposed query tree algorithms based on bit tracking, but these algorithms still have problems such as idle paging and redundant prefixes. In this paper, we start with an analysis of state-of-the-art anti-collision algorithms. Based on summarizing current works, we propose a Smart Batch-Processing protocol (SBP) for RFID multiple tag identification based on <inline-formula> <tex-math notation="LaTeX">$M$ </tex-math></inline-formula>-ary collision bit arbitration mechanism. In the SBP, the reader firstly maps <inline-formula> <tex-math notation="LaTeX">$m$ </tex-math></inline-formula>-bit collision bits into <inline-formula> <tex-math notation="LaTeX">$2^{m}$ </tex-math></inline-formula> slots and then predicts the distribution of tags in slots. Finally, the reader allows the tag to return the remaining part of its ID at the mapped slot using a batch-processing command. By using SBP, the reader can simultaneously identify <inline-formula> <tex-math notation="LaTeX">$2^{m}$ </tex-math></inline-formula> groups of tags in a slot. Besides, empty queries can be eliminated in the tag identification process. The description of SBP is given first, and then, its performance is theoretical analyzed and simulated. Both theoretical analysis and extensive simulation results show that the SBP algorithm reduces 22.94% and 22.28% of time and energy consumption compared to other <inline-formula> <tex-math notation="LaTeX">$M$ </tex-math></inline-formula>-ary collision bit arbitration based methods.

hybrid algorithms have been proposed in those literatures [6]- [12], which combine the characteristics of Aloha-based and tree-based algorithms. The core idea of such type of algorithm is that when the reader detects a collision, it precedes the collided tag set using a tree-based algorithm (the CNCAA algorithm proposed in [11] which uses both collided and non-collided parts of information in collision slots for tag's identification.). Although the system efficiency of the hybrid algorithm is higher than that of Aloha-based algorithms. For instance, the system efficiency reported in [9] can reach 48.5%; in the paper [12], the efficiency of this algorithm reached 73% by using the information available in the collision time slot, called conflict data, to uniquely identify labels. However, it does not guarantee that all the tags are identified. The implementation complexity of hybrid algorithms is also higher than Aloha-based algorithms. Besides, because of the need to use bit identification and tracking technology, it is not suitable for UHF RFID systems [6].
Tree-based algorithms [8], [13]- [23] require that when multiple tags send IDs simultaneously, the reader can accurately locate individual collided bits of tag ID string. Specifically, in ISO-14443/15693, the reader uses the Manchester code to identify the bit value of the ID string. The main idea of a tree-based algorithm is to maintain the string before the highest collision bit as the common prefix when the reader detects a collision, and then divides the collided tag set according to the collision bits. Some algorithms [8], [13]- [15] divide the collided tag set into two groups according to the highest collision bit. Many algorithms [16]- [21] divide the collided tags into M groups. There are still some algorithms [22], [23] adopting new grouping methods. In essence, a tree-based algorithm continuously separates collided tags into smaller groups until there is only one tag in the group. The main evaluation metrics for measuring the performance of the tree-based algorithms are time and energy consumption, which depend on the number of interactions between the reader and tags and the number of transmitted bits [24]. Many newly proposed algorithms focus on these two aspects.
In [13], CwT is proposed to reduce the number of transmitted bits between the reader and tags. The parameters sent by the reader to the tags include query prefix and w. After receiving the query command from the reader, the tag only returns a partial ID of length w instead of the remaining ID. However, if the sum of the length of w and the prefix is not equal to the ID length, the reader needs to send the query command again to obtain the complete ID. Thus, the number of interactions has been increased. In STT [23], when detecting a collision, the reader increases the length of the prefix, thereby skipping the redundant collision queries. When detecting an empty slot, the reader shortens the length of the prefix, thereby skipping the redundant empty queries. The advantage of the STT algorithm is to reduce the number of interactions. The demerit is that there are many empty slots. The MQT algorithm proposed in [19] defines a set of mapping rules (original m bits is mapped into 2 m bits). When the reader receives the mapped string returned by multiple tags simultaneously, it can recover the original data according to the mapping tables. The MQT can reduce the number of interactions between the reader and the tags. However, the number of transmitted bits has been increased due to the combined transmission of mapped data and the remaining ID. The NAA algorithm proposed in [16], which only uses the collision bits to generate a new tag's temporary ID and the followed operation only for this new ID. The NAA algorithm's processing of the new tag ID is mapping first transmitting later. When a collision occurs, NAA can recover the original data according to the mapping rules (original m bits is mapped into 2 m bits). The NAA can reduce the times of interactions between the reader and the tags. However, the amount of transmitted bits has been increased due to the combined transmission of mapped data and the remaining ID. The literature [17] proposes an MCT algorithm. When a collision occurs, the reader broadcasts the position of m-bit collision bit and the tags determine which slot to respond according to the value of collision bits. The merit of MCT is that the reader can potentially identify up to 2 m tags by preprocessing the m-bit collision bits. The demerit is that the reader needs to transmit query command at the beginning of each slot, and there are many empty slots.
The above work focuses on decrease the times of interactions between the reader and tags and the number of transmitted bits. However, their performance needs to be further improved because of a redundant prefix, unused collided bits, and idle paging. This paper proposes a new algorithm namely SBP based on the M -ary collision bit arbitration mechanism. In SBP, when a collision occurs, the reader first detects the actual distribution of m-bit collision bits through a BQ command (After receiving the BQ command, the tag will generate 2 m mapped string based on the value of original m bits). The reader then sends a batch-processing command CMD to allow the tags to know the detected results from the BQ command. The merits of SBP are two-fold. For one thing, the reader can predict the actual distribution of collision bits through BQ command, thereby effectively eliminating a large number of empty queries in traditional M -ary algorithms. For another, the tag responds to the reader in the corresponding slot based on the values of its collision bits, so that the reader can batch process the tags. Theoretically, the reader can recognize up to 2 m tags in a slot by sending a CMD command, which greatly reduces the number of queries.
The remainder of this paper is organized as follows. Section II introduces some preliminaries for our work. The basic idea and description of SBP are described in Section III. Section IV makes a theoretical analysis of the number of queries, the total time consumption, and the energy consumption of SBP. The simulation results are provided in Section V. Section VI summarizes this paper.

II. PRELIMINARY
We first introduce the basic principle of the M -ary collision bit arbitration mechanism. The reader will list 2 m possible outcomes of the highest m-bit collision bits and then divide the collided tags into 2 m groups. For example, when m = 2, four prefixes will be generated, pre = 00, 01, 10, or 11. And the collided tags will be divided into four groups. In the M -ary-based algorithms, the larger the m value, the more the number of groups. In order to achieve a compromise between the number of collision slots and empty slots, the value of m is usually set to 2 or 3 [18]- [20].
To reduce the number of interactions between the reader and tags, the SBP will batch-process the tags. In SBP protocol, multiple tags are identified by a reader at a time slot. Therefore, it is necessary to temporarily store tag ID information using a queue. The basic working principle of the queue is introduced as follows.
The queue is a special linear table that defines the operation positions of insertion and deletion. Specifically, the operation of inserting and deleting data into the queue can only be performed at the tail of the queue and at the head of the queue, respectively. In the proposed SBP algorithm, the reader maintains two queues which are Pque used to store prefixes and Bque used to store parameters of BQ command, respectively. We will introduce the usage of these two queues in the following sections.
The data communication between the reader and the tags is based on Manchester coding, that is, the data-0 and data-1 are identified through the transition of high and low levels. The reader can determine whether a collision has occurred based on the level conversion. It is worth noting that the SBP algorithm proposed in this paper is based on the strict synchronization of the data returned by the tags. The link timing diagram of the SBP algorithm is described in Fig. 1. As observed in Fig. 1, there are two types of commands namely BQ and CMD, respectively. t B and t C are the duration of transmitting BQ and CMD command, respectively. t 1 is the duration from the reader transmission to tag response. t 2 is the duration required for the reader to demodulate the tag signal. t BR and t CR are the transmission duration of tag response. Let Tbq(n) denotes the required number of times BQ command is sent, Tcmd(n) denotes the required number of times CMD command is sent, the time and energy consumption of SBP can be calculated as:

III. PROTICOL DESCRIPTION
In the proposed SBP algorithm, when a collision occurs the reader determines which of M = 2 m slots mapped by m-bit collision bits contain tags by sending BQ command. Then the reader sends CMD command to inform the tag in which slot it should reply to the reader. Through such a mechanism, the reader can eliminate the number of empty queries during the tag identification process. This section is mainly divided into three parts. First is the introduction of commands and registers that used in SBP protocol, the second part introduces the proposed SBP algorithm in detail.
To better describe the proposed SBP algorithm, the symbols and notations used in this paper are summarized in Tab. 1.

A. INTRODUCTION OF RELATED COMMAND, QUEUE AND REGISTER
In the SBP protocol, we used two commands, BQ and CMD, two queues, Bque and Pque, and one label register, RegM. Next, we will introduce them in detail.
BQ: It is a slot probing command. Ps indicates the prefix that the tag needs to match, i.e., when ID[1: | Ps|] = Ps, the tag will respond to the reader with its M value. Pc denotes the collision segment, i.e., data obtained by setting all the first m-bit collision bits as 1. Pp(i) denotes the position of the i-th collision bit. Where the first collision bit is the MSB of Pc and the m-th collision bit is the LSB of Pc. Thus, it is not necessary to record the position of the first and the last collision bits of Pc. CMD(B S , B L ): It is a batch processing command. Bs indicates the distribution of slots which is calculated from the reply of previous BQ command. B L is the length of the data string returned by the tag for the current CMD command. The value of B S is the string obtained by setting the collision bit as 1 received by the last BQ command and unchanging the noncollision bits. For example, when B S = 0001001, it means that the data will be transmitted between reader and tag only in the first and fourth slots and the remaining time slots are the idle slots. It is noted that when B S = ε and B L = L, the tags will respond to the full ID to the reader.
Pque: The queue is used to store prefixes in a first-in-firstout way. It can only insert the data at the tail of the queue and delete the data at the head of the queue. The process of popping out the queue is to read the first value from the queue and delete it from the queue, and then the previous second value becomes the new header of the queue. After receiving the response to the BQ command, the reader will update the value of Pque.
Bque: The queue is used to store the parameters of the BQ command. The queue's operation is the same as Pque. After receiving the response to CMD, the reader will generate a set of BQ command parameters and insert them into the tail of Bque if the recovered ID collides.
RegM: The M -bit register in the tag is used to store the mapped data of m-bit collision bits. After receiving the BQ command, the tag will update the value of RegM.

B. READER OPERATION
This section mainly introduces the proposed SBP algorithm in detail. Tab. 2 describes the mapped tables for m = 2 and 3. Initially, the reader initializes the parameters B S = ε, B L = L, Pque = null, and Bque = null.

1) IDENTIFICATION STARTING: THE READER BROADCASTS CMD(Bs, B L ) COMMAND a: THE GENERATING PROCESS OF BQ COMMAND PARAMETERS
After receiving the tag's response rID, the reader will directly identify the tag if no collision is detected. Otherwise, the reader will generate a set of BQ command parameters (P S , P C , P P (2) , . . . , P P(m−1) ) and insert them into the Bque. The generating process of BQ command parameters is as follows. Ps means the string before the highest collision bit. If the highest collision bit is the first bit, then Ps = ε. Otherwise, Ps = [1:rC(1)−1]. Pc denotes the collision segment, which can be obtained by setting the collision bits C(1), C(2), . . . , C(m) to 1. Pp(i) denotes the position of the i-th collision bit. As described in Fig. 2(b), when the reader receives rID = xxxxxxxx, the first bit is the highest collision bit and Ps = ε. In Fig. 2(b), the first three collision bits are C(1), C(2) and C(3) and rID [1:3] = xxx which are marked with red color, Then, Pc = 111. Since m = 3, the BQ command parameters generated by rID is (ε, 111, 2).

2) DETECTING THE DISTRIBUTION OF TAGS IN COLLISION SLOTS
The reader determines whether the Bque is null. If it is null, it indicates that all the tags within the reader's vicinity have been identified and the identification process ends. Otherwise, the reader pops out a set of parameters from Bque as the parameters of the BQ command. Then, the reader broadcasts the slot probing command BQ(P S , PC, P P(2) ,. . . , P P(m−1)) to the tags.

a: PREFIX COMPOSING AT THE READER SIDE
When receiving the tag response rS, the reader labels the position of rS, then generates a series of prefixes and pushes them into Pque. The calculation method of prefix is as follows: where 1≤j ≤m. As described in Fig. 2(b), the response to

3) BATCH PROCESSING ROUND
The reader pushes the (pre(1),. . . , pre(i)) into Pque and determines whether the value of B L = L-(|Ps|+|Pc|) is 0. If B L = 0, it means that the current pre is a complete ID, the reader will identify the tag and skip to step 2). If B L =0, it means that the current pre is not a complete ID, the reader will send CMD(Bs, B L ) to allow the tag to respond to the rest ID. As described in Fig. 2(b) step 2, the reader calculates that B L = L-(| Ps |+| Pc |) = 8-(0+3) = 5, after the command BQ, it means that the reader will send CMD(Bs, B L ) to allow the tag to respond to the rest ID. Set the collision bit (which are marked with pink color) in rS to 1 and we can get Bs = 10100101.

C. TAG OPERATION
In the SBP algorithm, there are only two commands received by the tag from the reader: the slot probing command BQ and the batch processing command CMD. In the following, we will introduce the tag's response to BQ and CMD in detail.

IV. THEORETICAL ANALYSIS
There are only two types of query commands in the SBP algorithm, named BQ or CMD commands. For ease of understanding, we regard CMD as a frame start command, and the BQ as a slot start command. Taking M = 2 m = 4 as an example, the reader can tackle two collided bits at a slot, and these two collided bits have four possible outcomes: 00, 01, 10, and 11. For a given slot, it has three states, collision, success, and empty.

A. NUMBER OF PAGING TIMES
In the SBP algorithm, when detecting a collision the reader sends a BQ command to detect whether there are empty slots in 2 m slots. Then the reader sends the detecting results to the tags, ensuring that there is no empty slot when the tag transmits the remainder ID to the readers. The number of times the BQ command transmitted is equal to the number of collision slots. Therefore, the total number of queries can be calculated as: where Sc(n) is the number of collision slots that will occur during the identification of n tags. The SBP algorithm divides the tag set into M (M = 2 m ) subsets through the batch command CMD, where m is the number of collision bits. Considering the random distribution of tag IDs, each collided tag set has M subsets. Define the divided subsets as Aj (j = 0, 1,. . . , M -1). Assume the number of tags to be recognized is n, then the probability that i tags fall into the same subset can be expressed as: Here in | * | means the number of elements in the set. For ease of analysis, taking m = 2 as an example, the reader can detect two collision bits. The corresponding subsets of two collision bits are A 0 = 00, A 1 = 01, A 2 = 10, and A 3 = 11. Only if the distribution of tags satisfies the following scenarios, the reader can detect two collision bits.
(a) Both A 0 and A 3 have at least one tag. (b) Both A 1 and A 2 have at least one tag.
, we can know that the probability of i tags falling into the A j subset is P(|A 0 | ≥1)∩(|A 3 | ≥1). Let Sc(n) denote the number of collision slots which can be expressed as: Proof: When n = 0 or 1, it is obvious that the reader can identify the tag by sending only one command. When n ≥2, we can calculate Sc(n) through a recursive method. When n ≥2, the tag's reply to the first CMD command must be a collision slot. The tag's reply to each batch command CMD is regarded as a data frame, and each frame contains M = 2 m slots.
Next, let's calculate the value of P(B 1 ∪B 2 ) part in formula (6).
then, we will calculate the P(B 1 ∪B 2 ||A j | = i) part in formula (6).
When A 0 = i(i =0), we arrived at: Similarly, When A 0 = i(i = 0), we have: Substituting formula (6)-(9) into formula (5), we can have Sc(n) = 0.58n. Similarly, we can have Si(n) = 0.73n. Furthermore, the total number of queries can be expressed as: Similarly, we arrived at the number of collision slots Sc(n) is 0.73n. Substituting (10) into (1), we can have: When adopting EPC-96 format to generate tag's ID and The parameter values used in the simulation are listed in Tab. 4, the simulation results of the average number of queries required to identify one tag is plotted in Fig. 3

B. TIME CONSUMPTION
In what follows, we analyze the time and energy consumption of the SBP algorithm. According to the above analysis and formula (1), the time consumption of the SBP can be written as: where Tcmd(1) is the transmission time of the initial CMD command. t B(i) is the time taken by the BQ command. t BR is the time spent for receiving and decoding the BQ command. t C is the transmission time of CMD command excludes the initial one. t CR(i) is the time spent on receiving and decoding CMD command. The values of t BR and t C can be found in Tab IV. The Tcmd(1) can be expressed as: The average time to identify one tag can be calculated as: Substituting formula (12) into (14), we can have: The part (a) in formula (15) can be derived according to Tab. 2 and formula (13).
Refer to the command format in Fig. 1 we have: Here in part (a) is known and part (b) is to be sought.
where |Ps |+|Pc | is the length of prefix contained in BQ. To find the value of D, we first assume that the traversal tree in the SBP algorithm is a full M -ary tree. In a full M -ary tree, the number of nodes in the kth layer is M k , where M = 2 m . Each node in SBP contains a BQ and CMD command. Thus, D can be expressed as: where N j=1 4 j ≤ 0.58n < N +1 j=1 4 j In which (a) is the total length of |Ps|+|Pc| in the previous N layer of full M -ary tree. (b) is the length of |Ps|+|Pc| of leaf nodes in the last layer. As we know Sc(n) = 0.58n and Si(n) = 0.73, the probability that an M -ary tree is a full M -ary tree can be expressed as: Sc (n)+n Sc (n)+n+Si (n) = 0.58n+n 0.58n+n+0.73n = 0.684 (18) Substituting formula (17) and (18) into formula (16), the value of Tb can be obtained. Similarly, the Tcr can be obtained by substituting formula (17) and (20) into formula (18).
Average number of non-empty slots in 2 m slots detected by each BQ command is written as: According to Tb, Tcr, and formula (15) the average time T for identity one tag of SBP can be derived. The calculation method of E(n) in formula (2) is very similar to T (n), the derivation process can be omitted. When adopting the data format illustrated in Fig.1 and parameters listed in Tab. 4, the simulation results of the average time and energy consumption for identifying one tag is depicted in Fig. 4.

V. PERFORMANCE VALIDATION
In this section, we compare the proposed SBP with the prior M -ary-based algorithms through extensive simulations. We mainly consider the following performance metrics. 1) Communication complexity at the tag side: the number of messages that need to be transmitted to the reader when the tag is identified. Because most tags are passive or powerconstrained, they require low energy consumption.
2) The number of queries: The number of interactions required by the reader to identify a tag, which affects the identification time.
3) Time consumption: The time it takes for the reader to successfully identify a tag, which is an important metric to evaluate the performance of the RFID anti-collision algorithm. 4) Energy consumption: The energy consumed by the reader to correctly identify a tag.

A. SIMULATION CONFIGURATIONS
In the simulations, the length of the tag's ID is 96 bits, and the tag's ID generation format is shown in Fig. 5. The format of CMD and BQ commands refer to Fig. 1. The parameters used in simulations have been listed in Tab. 4.
Where Tr means that the tag's ID is randomly generated. Th means that the header part is fixed and the rest part is randomly generated. Tm means that both header and manufacture parts are fixed and the rest part is randomly generated. Tp means that header, manufacture, and product are fixed, and the rest part is randomly generated. Tx means that the simulation generates 10 different types of tags, and these tags represent 1000 different types of products produced by 100 manufacturers. Before the tag identification, the reader does not know the number of tags and tag IDs.
All the results shown in Fig. 6 are obtained by averaging 100 experiments. Fig. 6 (a-d) compares the SBP algorithm with several representatives of tree-based algorithms including MQT, MCT, CwT, NAA, and STT. In Fig. 6 (a-d), all tag IDs are randomly generated with 96 bits (according to Tr in Fig. 5). Fig. 6 (e-f) compared the performance of the proposed SBP in time and energy consumption when the tag format obeys to Tr, Th, Tm, Tp, and Tx. . When m = 3, the average number of queries required by SBP is 0.85 which is at least 38.18% lower than NAA. When m = 3, the average number of queries required by SBP is 0.85 which is at least 38.18% lower than the method NAA which has the least average paging times. When m = 2, the average number of queries required by SBP is 1.15 which is at least 16.36% lower than the method NAA which has the least average paging times.   Fig. 6(c-d) plots time and energy consumption per tag identification. As can be seen, SBP is much better than comparative approaches in time consumption. The main reason is that the SBP algorithm uses a batch processing command to reduce the number of queries. Accordingly, the coordination time during tag identification is significantly reduced. Observed from Fig. 6(c), the time consumption is from less to more, the ranking is SBP, MQT, MCT, NAA, STT, and CwT, the proposed SBP reduces the time consumption by 22.94%, respectively, compared to MQT which have the least time-consuming. The energy consumption of the algorithm is proportional to the time consumption of the reader and tag. The SBP algorithm proposed in this paper is superior to the comparison of several algorithms in terms of reader time consumption and tag time consumption, so the energy consumption of the SBP algorithm is also lower than those algorithms that are compared in this paper. Observed from Fig. 6(d), the proposed SBP reduces energy consumption by 22.28% respectively, compared to MQT which has the least energy consumption. Fig. 6(e-f) compare the time and energy consumption per tag identification with various ID distributions. It can be seen from Figure (e) that when the tags are generated in different distribution, the time consumption of the SBP algorithm is Tp, Tm, Th, Tr, and Tx from less to more. The main reason is that the parameter pre (the prefix of tags) carried in the CMD command only needs to be sent once, and all tags whose register regM value is not equal to null will return the remaining ID to the reader in the corresponding time slot. Therefore, the lower average highest collision bit detected by the reader will lead to the longer prefix and the shorter remaining ID, which in turn leads to the smaller amount of interactive data between reader and tags, the smaller SBP algorithm's time overhead. Observed from Fig. 6(e-f), under different ID distributions, the proposed SBP algorithm only needs a maximum of 1.48ms and 1.35mJ to recognize a label, which is better than the benchmark algorithms compared in this paper in time and energy consumption.

D. EFFECT OF TAG DISTRIBUTION ON SBP ALGROITHM
In summary, simulation results in Fig. 6(a-d) verify that the proposed SBP is superior to other tree-based algorithms under the condition that the tag's ID is randomly distributed. Simulation results in Fig. 6(e-f) verify that regardless of tag ID distribution, the proposed SBP algorithm can maintain the constant performance.

E. EFFECT OF PATH LOSS AND CAPTURE EFFECT ON SBP ALGROITHM
Due to the path loss and capture effect in communication links, there will be a certain discrepancy between the actual performance and the ideal performance of an algorithm. In what follows, we will explore the actual performance of the SBP algorithm. Firstly, we analyze the influence of path loss and the capture effect on identification performance.
The reason for the path loss is mainly due to the distance difference between the reader and tag, obstacles, transmission power, and other factors. As a result, the transmitted and received signal is attenuated, causing the reader to identify the tag in vain. When path loss occurs, the collision slot may be erroneously detected as a success slot or an empty slot,  and the success slot may be erroneously detected as an empty slot, which is shown in Fig. 7. In tree-based algorithms, the involved tags resulting from path loss cannot be identified in the current identification round. And they will participate in the next identification round.
Since the distance between the tags and the reader is different, the backscatter signal strength at the reader side is different. When the signal strength of a certain tag is significantly stronger than other tags, it will cause a capture effect. The capture effect will only affect the collision slot. When it occurs, the original collision slot may be converted into a success slot, thereby speeding up the identification process In the following, we evaluate the performance of the algorithm in a realistic environment (with path loss and capture effects). In simulations, the probability that the tag can be successfully detected by the reader is defined as Ps, where Ps is from 0.9 to 1. The occurrence probability of capture effect is defined as Pc, where Pc is from 0 to 0.3. The tag format can be referred to Tr in Fig. 5.
As can be seen from Fig. 8, the smaller the Ps value, the fewer number of tags per second that the algorithm identifies. The larger the Pc value, the more tags per second the algorithm identifies. In summary, when P S and Pc change dynamically, the average number of tags per second identified by the SBP algorithm is the highest, followed by the MQT algorithm, and the MCT algorithm is the least.  Fig. 9 shows the average energy consumption per tag identification in a realistic environment. It can be seen that the energy consumption of identifying a tag decreases as the value of Pc increases, and the larger the value of Ps, the smaller the energy consumption. As observed in Fig. 9, the overall energy consumption of SBP is lower than that of MQT and MCT algorithms.

VI. CONCLUSION
In this paper, we propose a smart batch processing (SBP) protocol for tag identification. In the SBP, once the reader detects a tag collision, it will first form an optimal M -ary traversal tree and then send a batch processing command to allow multiple tags to be identified in a slot. Through theoretical analysis and simulations, we prove that our proposed SBP algorithm is superior to other tree-based algorithms in terms of the number of queries, communication complexity, identification times, and reader energy consumption. Besides, the performance of SBP is verified under different tag ID distributions. Simulation results show that the proposed SBP still maintains a good performance under various tag ID distributions. Finally, we evaluate the performance of the SBP algorithm in a realistic environment with path loss and capture effects, which also proves that it is still better than other comparative algorithms.