4.1
Description of the Prefix-Tree Algorithm
The 900MHz Class 0 Protocol Standard implements a binary tree anti-collision algorithm to prevent information loss. It reads the whole ID code for recognition purposes.
We follow the architecture in the Class 0 Protocol Standard, but modify the algorithm that interacts with the reader and the tag. To reduce the recognition time, we improve the binary tree to form a prefix-binary tree. In the first step, tags to be
recognized are pre-registered in the prefix-tree, after which, they traversal the tree for recognition. When the tags containing the IDs require to be recognized, we operate the prefix-tree for performing recognition. Our approach does not need to read the whole ID code; it only receives the parts of the code that identify the tag.
4.2
Structure of the Prefix-Tree
The prefix-tree structure can divide into three parts. We use the leaves to store the IDs of the tags. The root and the internal nodes store the control information of the prefix-tree. The control information can decide the growth of prefix-tree and the
direction of the recognition process.
When there are two registered tags, there must have one internal node which split them into two leaves. The basis of split is collision bit position which is stored in each internal node. To determine the number of registered tags, the root and each node have counters to record respectively.
In recognition process, the back-track pointer would indicate the node which ever had a collision.
Root
¾ Does not register tag
¾ Use a counter to record the number of registered tags of the left and right sub-trees respectively
¾ Record the collision bit position as 1
Collision bit position: two different IDs should have first different bits from MSD, where is collision bit position
z Internal Node
¾ Does not register tag
¾ Use a counter to record the number of registered tags of the left and right sub-trees respectively
¾ Record the collision bit position
z Leaf
¾ One leaf register one tag
4.3
Building a Prefix-Tree
In this section we describe the construction of the prefix-tree. Note that the collision bit position, the prefix-tree uses it to decide the growth. Here are the definition of building a prefix-tree.
z Tags are registered one by one.
z The prefix-tree starts from the root
z Root and internal node has to record the number of tags registered on the left and right sides of the sub-tree.
z Each leaf can only register one tag
z When a tag needs to be registered, it passes through the registered path of the nodes, to find the collision bit position. According to the collision bit
position, we put the registered tag(s) belonging to the node into the left sub-tree if the collision bit is 0, and into the right sub-tree if it is 1.
In Figure 3.9, four tags are registered in the prefix-tree, three on the left and one on the right of the root. The procedure for generating a prefix-tree is as follows:
1. The tree begins at the root and every node, including the root, has three parameters: < Left tag counter, Right tag counter, collision bit position >, where tag counter is the number of tags registered as belonging to the node.
The collision bit position of the root is default 1.
Figure 3.2: Pre-Registered Phase 1
2. The first tag, tag1, is registered and the data 0 at the first bit lets the Left tag counter increase to 1.
Figure 3.3: Pre-Registered Phase 2
3. Tag1 is registered to node1 of the left sub-tree because of the first bit is 0.
Figure 3.4: Pre-Registered Phase 3
4. When tag2 is due to register, as the data is 0 at the first bit, the Left tag counter of the root, and the Left tag counter and Right tag counter of node1 all increase to 1. The collision bit position of node1 is 2.
Figure 3.5: Pre-Registered Phase 4
5. Based on the collision bits, tag1 is added to node3 for data 0 and tag2 is added to node4 for data 1.
Figure 3.6: Pre-Registered Phase 5
6. We add tag3 and tag4 according to the above steps to obtain the tree shown in Figure 3.7.
Figure 3.7: Pre-Registered RFIDs on an Efficient Prefix-Tree
4.4
Recognition
Next, we’ll explain how the prefix-tree recognizes tags. In this process we add a back-track pointer, which can avoid reading repeatedly from root after a tag was recognized.
z During the traversal procedure, each node only expects the bits at its
recorded collision bit position. It ignores bits received before until the bit at the recorded collision bit position.
z The prefix-tree uses a back-track pointer to record the current traversal node when a collision occurs.
z When collision occurred, the node whose registered tag counter of both sub-trees are the same as one. In this case the reader can recognize them simultaneously.
z Traversaling to the sub-tree of fewer tags which compared by left and right tag counter.
z If the tag counter of the left and right sub-trees are equal, we consider which sub-tree has the lowest level node to traversal. This thinking we want to quickly reduce the interference of signals transmitted from tags
simultaneously.
z When one sub-tree is traversaling, the tags of the other sub-tree must be put on hold till called for remaining.
z If back-track pointer(s) exist(s) when one tag recognized completely, hop to the node indicated by closest back-track pointer; otherwise, the recognition process finishes.
z When the process goes back to the node indicated by back-track pointer, read next bit and goes to next node.
Here, we use the prefix-tree in Figure 3.7 to recognize tag2, tag3, and tag4.
Assume that tag1 is not in the field for recognition.
1. A collision occurs at the first bit of the root.
Figure 3.8: Recognition Phase 1
2. We select the least registered tag on the right of the sub-tree and make tag2 and tag3 hold; and create Back-Track Pointer1 to record the collision node.
Figure 3.9: Recognition Phase 2
3. Tag4 is registered by node2, which recognizes it. Tag4 then goes dormant.
Figure 3.10: Recognition Phase 3
4. Hops to root with Back-Track Pointer1 and calls tag2 and tag3 for remaining.
Node1 expects the collision bit position at the second bit, but there is no collision. Hence, it continues traversaling the tree to node4.
Figure 3.11: Recognition Phase 4
5. Node 4 expects the collision bit position at the fourth position; therefore, it does not consider the third bit. While it is at the fourth bit, a collision occurs.
Figure 3.12: Recognition Phase 5
6. Here is a collision on node4 and the both sub-trees’ registered tag counter are the same one, and then the reader recognizes tag2, tag3 simultaneously.
Figure 3.13: Recognition Phase 6