Event-Based Sensor Processing via Timeslot Map Updates
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Event-based sensors produce asynchronous events that require efficient processing and memory access, which is resource-intensive due to the need for chronological ordering, limiting the use of local memory schemes like caching.
Innovation Solution
A method that groups events into timeslots, allowing for the use of more convenient ordering and reducing memory access by building a map during each timeslot and updating the data structure efficiently using faster memory architectures, such as local cache for building the map and global RAM for storage.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Measurement precision
If events are processed in chronological order from asynchronous pixels, then temporal accuracy is maintained, but memory access frequency increases and processing resources are consumed
Solution Approach 1:
The patent segments the continuous stream of asynchronous events into discrete timeslots. Each timeslot collects events from all pixels independently, breaking the chronological processing requirement into manageable temporal chunks. This segmentation allows the system to process events in batches rather than individually, reducing memory access frequency while maintaining acceptable temporal resolution through the timeslot granularity.
Solution Approach 2:
The patent implements periodic action by establishing fixed timeslots at regular intervals. During each timeslot, the system periodically collects events from all pixels simultaneously, then processes the accumulated data as a batch. This periodic structure transforms the continuous asynchronous stream into discrete processing cycles, enabling efficient memory utilization and reducing the need for frequent random access operations.
2Reliability
If events are stored in RAM with pixel addresses, then spatial relationships are preserved, but random memory access increases resource consumption
Solution Approach 1:
The patent merges events from all pixels within each timeslot into a unified data structure organized by spatial coordinates. Instead of accessing individual pixel addresses randomly, the system combines all events occurring within a timeslot and organizes them in a structured format that preserves spatial relationships while enabling sequential or block-based memory access patterns, significantly reducing the energy cost of memory operations.
Solution Approach 2:
The patent introduces an intermediary data structure that acts as a buffer between the asynchronous event stream and the processing logic. This intermediary structure, organized by spatial coordinates rather than chronological order, mediates the transformation of scattered asynchronous events into a coherent spatial representation, reducing random memory access by enabling batch processing and improving cache utilization.
3Speed
If local memory caching is used for event data, then memory access speed improves, but chronological ordering requirements limit caching effectiveness
Solution Approach 1:
The patent applies preliminary action by pre-organizing events into timeslots before processing. During the collection phase, events are buffered and sorted by spatial coordinates in advance, preparing the data in a cache-friendly format. This preliminary organization enables subsequent processing to utilize local memory caching effectively, as the data is already structured for efficient batch access rather than requiring complex dynamic reordering during processing.
Data Source
AI summary
The method processes a series of events received asynchronously from an array of pixels of an event-based light sensor. Each event of the series comprises an address of a pixel of the array from which the event is received, and an attribute value depending on incident light sensed by that pixel. The method comprises: storing a data structure in a first memory, the data structure including event data for at least some of the pixels of the array, the event data for a pixel being related to at least one event most recently received from said pixel; during a timeslot, building, in a second memory having a faster access than the first memory, a map for the pixels of the array as the events of the series are received, the map including an information element for each pixel of the array, the information element having one of a plurality of values including a nil value indicating an absence of event during the timeslot; and updating the data structure after the timeslot using the map.