Concatenated Pointers for RFID Tag Memory Brownout Safety
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Radio frequency identification (RFID) tags face issues with power loss during write operations, leading to incomplete or corrupted memory pointer updates, particularly during 'brownout' conditions, which can result in accidentally unlocking previously locked memory regions and wasting nonvolatile memory when multiple items are written and locked.
Innovation Solution
Implementing a system with two 'brownout-safe' pointer registers that are logically concatenated to form a complete address, using a coarse and fine pointer combination, such as a Gray-coded or linear bitmap pointer, to ensure accurate locking and minimize memory waste by allowing fine-grained protection without requiring full block locking.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Device complexity
If a traditional log pointer is used to indicate the boundary between locked and unlocked memory, then the pointer can represent a large range of addresses using few bits, but power loss during pointer update can corrupt the pointer and accidentally unlock previously protected memory
Solution Approach 1:
The pointer is divided into multiple segments (MSB segment and LSB segment) that are updated separately. The MSB segment is updated first, then the LSB segment. This segmentation allows the system to track the update state and detect power loss conditions, preventing corruption of the complete pointer value while maintaining a compact representation.
2Reliability
If Gray-coded address pointer is used to increment addresses, then only one bit changes per increment reducing brownout corruption risk, but large address changes require many successive write cycles reducing throughput and tag life
Solution Approach 1:
The address update operation is segmented into two independent write cycles: one for the MSB segment and one for the LSB segment. This allows larger address changes to be accomplished in just two write cycles rather than requiring multiple sequential Gray code increments, significantly improving throughput while maintaining reliability through the segmented update mechanism.
Solution Approach 2:
The MSB segment is updated in advance before updating the LSB segment. This preliminary action ensures that the most significant changes to the address are committed first, establishing a stable base for the subsequent LSB update and enabling the system to detect and handle power loss conditions effectively.
3Reliability
If bitmap pointer is used to indicate locked memory blocks, then each bit controls a separate block allowing independent protection, but large memory sizes require very large bitmaps increasing memory usage
Solution Approach 1:
The pointer address space is segmented into high-order and low-order portions. The high-order segment identifies the general region or block, while the low-order segment identifies the specific address within that region. This hierarchical segmentation reduces the total number of bits required compared to a flat bitmap approach, while still enabling fine-grained control over individual memory blocks.
4Quantity of substance
If linear pointer with large block size is used to reduce bitmap size, then memory usage decreases, but significant portions of each block are wasted when locking individual items
Solution Approach 1:
The pointer is segmented into multiple fields (e.g., bank identifier, high-order address, low-order address) that can independently address different regions and offsets within the memory. This fine-grained segmentation enables precise addressing of individual items or small groups of items, allowing the system to lock only the specific memory locations that need protection without wasting space by locking entire large blocks.
Data Source
AI summary
Methods and systems are provided for improved protection of radio frequency identification tag memory by using two or more “brownout-safe” pointer registers (instead of a single pointer register) that are logically concatenated to form a complete address for the boundary between a locked portion and an unlocked portion of the tag memory. A first pointer is a coarse pointer identifying a block of memory containing the boundary. A second pointer is a fine pointer identifying a specific location within the identified coarse block of memory. The coarse pointer may be a gray-coded or linear pointer. Similarly, the fine pointer may be a gray-coded or linear pointer.