In tree-based tag anticollision protocols, a reader divides tags into two groups. A reader further divides each of them into two groups again. It is required that a reader be able to distinguish each divided group. The process of dividing tags is continued until a group contains only one tag so that each tag could be successfully identified. The dividing process of a group is continued until a reader identifies all the tags.
Tree-based protocols work similar to census. The reader can recognize all tags in its identification range. An identification process of the reader can be illustrated as a process of creating and searching a tree where a node in the tree represents a reading slot. As stated earlier, the result of identification can be classified into three cases: readable, idle, and collided. After the identification cycle is completed, a tree is constructed. A leaf node in the tree corresponds to either readable slot or idle slot, and an intermediate node represents a collided slot.
Both the query tree [3,4] and binary tree [5,6] protocols represent a tree-based RFID tag collision protocol. Although each of them has different dividing algorithms and tree maintenance methods, they are very similar with respect to constructing a searching tree in an identification cycle. The main advantage of tree-based tag anticollision protocol is that all tags in identification range of the reader can be identified. An identification cycle is a process that constructs a tree from root node to leaf nodes. When the next identification cycle begins, information of tree in the previous cycle is initialized. AQS protocol [7] and ABS protocol [7] can improve the performance by using the information of tree in the previous cycle.
9.3.1 Query Tree
A reader transmits a query to tags using a query tree protocol. The query contains the prefixes of the tag identification (ID) codes. All tags within the range of a reader compare the query of the reader with their ID codes and transmit their ID codes to the reader when the result of the comparison is true. This protocol uses a query of reader and prefixes of tag ID codes to divide tags into two groups. Tags in one group transmit their ID codes to the reader while tags in the other group wait for the next query of the reader.
The content of a query is the identifier of each group. The reader repeats dividing tags into two groups until the number of tags in a group is one. When the number of tags in a group is one, the reader is successful in identifying the tag. This identification process can be considered as constructing a searching tree based on tag ID codes. The reader increases the length of the query until the identification cycle is completed.
The operation of the reader can be implemented by using a data structure (e.g., queue or stack). The queries set to 0 and 1 are stored in the data structure initially. When a collision occurs, the reader makes two queries whose lengths are 1 bit longer than the queries which cause the collision by concatenating query and the extra bit (0 and 1). Then the reader inserts itself to the stack or queue. When a readable slot or an idle slot occurs, the reader gets a next query from the data structure without any further processing. In case of using a stack for the data structure, the search is depthfirst search like the binary tree. When a queue is used, the search is breadthfirst search.
In Figure 9.3, we give an example of the identification procedure of the query tree protocol. The queue is initialized with null query. At the first reading slot, all tags reply and a collision occurs. It makes reader push query ‘‘0’’ and query ‘‘1’’ into queue. The reader extracts the query‘‘0’’from the queue and transmits it to tags. Three tags (001, 010, and 011) which start with ‘‘0’’ reply simultaneously and a collision occurs. The reader
pushes query‘‘00’’and queries‘‘01’’ into the queue. At the next reading slot, the reader transmits query‘‘1’’to tags and two tags (110 and 111) reply. Both queries‘‘10’’and‘‘11’’ are pushed into the queue. A tag with its ID ‘‘001’’ is identified successfully at the next reading slot. At this point, the queue has three queries (01, 10, and 11). The reader transmits query‘‘01’’in the next reading slot. Two tags (010 and 011) which start with‘‘01’’reply and a collision occurs. The reader pushes query‘‘010’’and query‘‘011’’into the queue. In this way, tag identification process is continued until the queue is empty. There are five collided slots, one idle slot, andfive readable slots under the query tree protocol.
9.3.2 Binary Tree
The binary tree protocol uses the pseudo-random number generator to divide tags into two groups. The counter variable in each tag is used for identifying each group. At the beginning of identification operation, the reader sends a message which notifies the start of its cycle to tags. All tags receiving this message generate random numbers of 0 or 1. Tags set their counter values by adding the generated random number to their counter values. Tags are divided into two groups: one group has 0 in their counter values; the other group has the counter values of 1.
The group with the counter value of 0 tries to transmit and wait for the reply from the reader. If a collision occurs, tags which tried to transmit their ID codes in the previous cycle are divided into two groups by using a pseudo-random number, and tags that did not try the ID transmission increase the value of their counters by 1. If there are no collisions, all tags decrease the value of their counters by 1.
The tags identified successfully set the value of their counters to 0 and wait for the start of a frame message from the reader. Since the binary tree protocol uses the random number generator in branching out, idle slots can occur many times. However, the probability of this is very low. As the information regarding tag ID codes is not used in the identification process as in probabilistic tag anticollision protocols, the performance of the binary tree protocol is not affected by the distribution of the ID codes of tag population.
In Figure 9.4, we provide an example of the identification procedure of the binary tree protocol. Initially, all tags set the value of their counter variables to 0. The tags with the counter value of 0 try to transmit and a collision occurs. Each tag generates random number of 0 or 1. Tag A, tag B, and tag D choose 0 as their counter value and make one group. On the other hand, tag C chooses 1 as its counter value and makes another group. In the next reading slot, the former group tries to transmit and a collision occurs. The reader
Query Medium Collision Slot Tag 011 0 l 1 1 l 00,01 1 l 01,10,11 01 l 10,11 10l1,010,011 11 l 010,011011,110,111010l 011 l 110,111 110 l 111 111 φ Tag 001 Tag 010 Tag 001 Tag 010 Tag 011 Tag 110 Tag 111 Tag 001 Tag 010 Tag 011 Tag 110 Tag 111 Tag 001 Tag 010 Tag 011 Tag 110 Tag 111 Tag 010 Tag 011 Tag 110 Tag 111 Tag 010 Tag 011 Tag 110 Tag 111 Tag 010 Tag 010 Tag 011 Tag 011 Tag 110 Tag 111 Tag 110 Tag 111 Tag 011 Tag 110 Tag 111 Tag 110 Tag 111 Tag 111 Tag 110 Tag 111
Collision Collision Tag 001 Collision Collision Collision Tag 010 Tag 011 Tag 110 Tag 111
FIGURE 9.3
informs tags of the result of current reading slot. Tag C which has nonzero value of its counter increases its counter value by 1. Tag A, tag B, and tag D generate random number and add it to their counter value. Since tag A and tag B have the counter’s value of 0, they perform transmission and a collision occurs. Tag C and tag D which have nonzero value of their counter increase their counter value by 1. Tag A and tag B generate random number and add it to their counter value. Tag A tries to transmit its data to reader because it has its counter’s value of 0. In this case, tag A is successfully identified. The reader notifies the result of current reading slot. All tags decrease their counter value by 1. In this way, tag B, tag D, and tag C are identified in successive reading slots.
9.3.3 Adaptive Query Splitting
AQS protocol is the method that can reduce a search space of a current identification process by using the queries in the leaf nodes of the tree which were constructed in the previous process. Searching from the leaf nodes of the previous tree can decrease identi-
fication delay present in the existing search method of query tree protocol that starts from root node of tree while covering all possible search spaces.
The reader maintains a queue Q as well as a candidate queue CQ. There are prefixes of tag ID codes in readable slots and idle slots from the previous identification cycle in CQ. At the start of the identification process, the reader initializes Q with the CQ and empties out CQ.
Figure 9.5 shows the operation of query tree protocol and the AQS protocol. If popula- tion of tags is same as in the previous identification cycle, no collisions occur in the current cycle under AQS protocol. If there exists an incoming tag whose ID matches a prefix of readable nodes in the previous cycle, it decreases the number of collision nodes to use prefixes of readable nodes. A new tag, whose ID does not match a prefix of a readable node in previous cycle, is quickly identified with prefixes of idle nodes in previous cycle by the reader.
To prevent the growth of CQ (which carries information of leaf nodes), the query deletion process is used. The query deletion process is the process that merges queries
Slot Tag A Tag B Tag C Tag D Counter 0 Tag A Tag A Tag A
Tag A Tag B Tag D Tag C Tag B
Tag B
Tag B
Tag C Tag C Tag C
Medium Collision Collision Collision Tag D Tag D Tag D Tag B Tag C Tag D Tag D Tag C Tag C 0 0 0 0 0 0 1 2 3 2 1 2 1 1 1 FIGURE 9.4
that share the same query content except the last bit. Idle nodes unnecessarily disturb the speed of identification, and CQ can eliminate prefixes of unnecessary idle nodes. For example, if the nodes of the prefix p0p1 . . . pi0 and p0p1 . . . pi1 contain at least one idle node and the non-idle node is a readable node, CQ stores the prefix p0p1 . . . pi instead of the prefix p0p1 . . . pi0 and p0p1 . . . pi1.
9.3.4 Adaptive Binary Splitting
ABS protocol is the method by which tags remember their identification order in the previous cycle by adding one to the counters in the tags. A tag maintains a progressed-slot counter (PSC) as well as an allocated-slot counter (ASC). PSC maintains the number of timeslots passed in an identification cycle. At the start of an identification cycle, PSC is initialized to 0. In every readable slot, all tags increase their PSCs by 1. ASC determines whether a tag can transmit its data. If a tag has the same value for both ASC and PSC, the tag can transmit.
A tag can be in one of the following three states:
. Wait state: If the tag has ASC greater than PSC, it waits for a command from the reader.
. Active state: If a tag has ASC equal to PSC, it transmits its data to the reader.
. Sleep state: If a tag has ASC less than PSC, the tag does not transmit any data. This tag waits for the next identification cycle since it has already been identified in the current identification cycle.
Adaptive query splitting 001
011 110 111 011 110
Set of tags is changed 111 111 110 011 001 000 Medium Query 00 l 10 010 011 110 111 10 l 010 011 110 111 000 001 010 l 011 110 111 000 001 011 l 110 111 000 001 110 l 111 000 001 111 l 000 001 000 l 001 001 Collision Idle Idle Readable Readable Readable Readable Readable 001 000 CQ: 00 10 010 011 110 111 010 FIGURE 9.5
In a collided slot, the colliding tags, the tags of the active state, add a random number (0 or 1) to ASC. The active tags with the addition of 1 in their ASCs convert their state into wait state. The tags in wait state increase ASC when collision occurs. When the reader sends tags the message which means the idle slot, the tags in the wait state decrease ASC.
Figure 9.6 shows the operations of the binary tree protocol and ABS protocol. If the tag population does not change, neither collision nor idle occurs in the current cycle under ABS protocol. The reader remembers the number of tags in the previous cycle and informs them of it at the start of an identification cycle. If there are incoming tags, they randomly set their counters into a smaller value than the number sent by the reader. Incoming tags can cause collisions with existing tags. When a collision occurs, those collided tags add a randomly selected binary number (0 or 1) to ASC. If there are leaving tags, an idle slot can occur.