Adaptive Splitting Protocols for RFID Tag Collision Arbitration

1. Adaptive Splitting Protocols for RFID Tag Collision Arbitration Jihoon Myung and Wonjun Lee ACM Mobihoc 06

2. RFID Systems -- what are they? • An automatic identification system -- used in tracking objects. • Typically large volumes of objects -- each object has a tag. • A limited number of readers are used to track the tags. • Readers send out signals that supplies power and instructions to tags. • Tags would then respond with their IDs -- used by the reader to track the corresponding object.

3. Motivation for RFID • Replaces bar-code based identification methods -- no need to have line of sight (bar code requires optical view). • Easier to have a unique ID for each object. • Could also be used for other applications -- medical applications -- health monitoring etc.

4. What are the Networking Issues? -- My take • Collision Avoidance -- large number of tags communicating with a small number of readers. • Load balancing between readers. • Are there issues similar to hidden terminals ? Need to be addressed. • Reader mobility -- something that could help. Does this bring about other issues ?

5. In this paper ... • The goal is collision avoidance. • Typically, if there are a large number of transmitters, sending low amounts of data, tree splitting algorithms are used. • The goal is to increase the efficiency of such algorithms for the scenario under consideration.

6. Roadmap • Problem Description • Prior algorithms -- why they are inefficient ? • Changes proposed to these algorithms in this paper. • Performance results. • Open discussion.

7. Problem • Simultaneous transmissions in RFID lead to collisions. • Increase in transmission delay, overhead. • Two types of collisions: • Reader collisions -- readers query a tag simultaneously. • Tag collisions -- Multiple tags transmit IDs to a reader.

8. Requirements/Constraints • Reader should recognize tags within its range. (Note reader does not know how many tags are present). • This recognition should happen with efficiency -- objects may move -- it may be important to track the trajectories. • Finally, resources are important -- tag has low power (obtained from reader), limited memory and low computational power.

9. Random Access • Aloha & Slotted Aloha -- good for the scenario under consideration but collisions can happen. • Tag starvation -- some tags may not be identified for long times. • Tree based protocols -- binary tree protocol and query tree protocol -- do not cause starvation -- but could incur delays. • Split colliding tags into subsets and try to recursively do this until a subset has only a single tag.

10. Key Idea in this paper • Use information in previous round to make decisions in current round. • This is a useful technique -- current protocols tend to ignore the fact that this information is available. • Two approaches are proposed -- one a variant of the query tree protocol and the other a variant of the binary tree protocol.

11. Binary Tree Protocol • Each tag has a counter -- initialized to zero. • A tag is also allowed to transmit when its counter is zero. • So, in the beginning there are collisions. • Reader transmits a feedback message to inform tags of collisions. • Upon collision, a tag randomly chooses a binary number that is added to its counter. • With this, at the next attempt, only those tags whose numbers are less than Max/2 transmit (set split into two sub-sets). • The process continues.

12. Binary Tree Protocol (cont) • When a collision occurs, a tag that is not involved in a collision, increases its counter by 1. • When a successful transmission is seen, tag decreases its counter by 1. • There is a frame structure -- (not clearly discussed) -- all collisions resolved within the frame. • A tag that is recognized does not transmit until the ongoing frame is complete.

13. Query Tree Protocol • The QT protocol uses tag IDs to split a set. • Reader queries with a bit string -- e.g. may begin with just sending a 0 or a 1. • If it is a 0, all tags whose IDs begin with 0 respond. • If collisions occur, then, a new query with two bits is sent and so on.

14. QT (continued) • The process terminates when all tags are recognized. • QT is memoryless -- tags need not maintain counter values and remember what has happened -- based on IDs. • However, there is a delay penalty. • There may be queries that may produce nothing since tags corresponding to the particular IDs may not be within the reader’s footprint.

15. The Problem with BT and QT • The problem that the authors identify is that the algorithms are started from scratch at the beginning of each frame. • However, many tags may be still within the reader’s footprint. Thus, it is probably not a good idea to go through collisions and resolution again. • Since the reader already has some information about the staying tags, it should use this information. • However, there may be newly arriving tags and tags that leave -- these need to be accounted for.

16. Contributions • Adaptive Query Splitting -- a variant of the QT approach. • Adaptive Binary Splitting -- a variant of the Binary Tree Protocol.

17. Definitions/Observations • A frame in a tree-based approach is represented by a tree structure. • Three kinds of cycles -- • Idle Cycle -- no transmission • Readable Cycle -- exactly one transmission • Collision cycle -- collision • In the tree structure -- all leaves are either idle cycles or readable cycles.

18. Adaptive Query Splitting • The key idea is to maintain two queues Q and CQ. • Q contains queries to be made. • CQ contains leaves. • At the beginning of a frame, contents of CQ are first moved to Q. • During the frame, CQ compiles the readable and idle cycles.

19. Query Deletion • As empty cycles are discovered (due to nodes leaving), the process prunes out empty cycles thereby reducing the height of the tree.

20. Algorithmic Representation

21. Adaptive Binary Splitting • ABS starts tag identification from the readable cycles of the previous frame and uses random numbers for the splitting procedure. • It avoids the delays that may be incurred due to empty cycles in AQS. • Staying tags revise their counters into the order in which they were recognized in the last frame. • Arriving tags choose a counter value at random.

22. ABS: Details • A tag has two counters -- Progressed Slot Counter (PSC) and Allocated Slot Counter (ASC). • PSC is initially `0’ and is increased by `1’ only in a readable cycle. • Same for all tags • A readable cycle is made known by the reader. • ASC signifies the cycle in which a tag can transmit its ID. • A tag is allowed to transmit if ASC=PSC.

23. ABS: More Details • If ASC < PSC, tag has already been recognized -- does nothing. • Upon collision, colliding tags increase their ASCs. • They randomly choose either 1 or a 0 and adds it to ASC. • Tags which have ASC greater than PSC will also increase their ASCs by 1 to prevent collisions from tags that increase their ASCs as above. • Since PSC is unchanged, tags that add a `0’ contend in the next cycle and so on. • Note that this set will be resolved before the set that chooses a `1’.

24. ABS: Even More Details • In each idle cycle, the tag that has not been recognized but with ASC > PSC will decreases its ASC by 1. • At the end of a frame, a recognized tag gets a unique ASC. • It preserves this ASC in the next frame -- this makes the search process much more efficient.

25. Terminated Slot Counter • Another slot counter called the terminated slot counter (TSC) is maintained. • TSC is increased each time there is a collision (note collision indicates at least two nodes transmitting with the specific ASC). • In the first cycle, the reader begins with a TSC of zero and goes with the TSC at the end of the frame to the next frame. • If there are collisions in the next frame, TSC is automatically increased. • Thus, this adaptively tries to keep track of the tags in the system. • Process terminates when PSC > TSC.

26. Miscellaneous details • Authors do not prove correctness --somewhat important. • Performance analysis conducted for worst case delay estimation. • The delays are computed assuming that the reader footprints are independent of each other -- in fact the algorithms also work with this assumption. • Else, collision among tags from different reader footprints can occur; there is no discussion on how this can be addressed.

27. Sample Performance Results • Generic spirit of the results suggests that collisions go down, the overhead is decreased (reduced collisions) and delay decreases. • Variety of parameters considred (won’t go into it.).

28. My take • RFID systems need more careful assessment -- how much is the memory of the tags, how much is the processing capability ? • Can whatever we design apply given realistic values of these ? • How do supply chain systems work ? Is there an interfacing issue with databases and RFID tags -- how long does it take to query etc. ? • Realism is the key !

29. In the larger context... • I think it is important to identify interesting topics or applications. • Understand what are the networking implications in this new setting. • RFID is one such technology/application. • Cognitive radio ? What are the challenges ? • Others ?