Method and apparatus for recording event data in a vehicle

Abstract

The invention relates to a method for recording event data in a vehicle, continuously receiving vehicle data from at least one vehicle system (3) and writing it as event data into data frames (DR) of a predefined size, wherein the individual data frames (DR) are written into at least one volatile memory (50), wherein the stored data frames (DR) are managed and kept available in the at least one volatile memory (50) until the event data stored in the individual data frames (DR) is older than a predefined maximum previous event time point or is continuously stored in at least one non-volatile memory (46) in reaction to an identified predefined event, wherein at least one partition of a predefined size is provided, the received reference information of the individual data frames is written into the partition in an arbitrary chronological order, wherein a chronologically randomly ordered subsequence of the written reference information of the individual data frames (DR) in the at least one partition is ascertained and marked, and to a device (1) for carrying out the method for recording event data in a vehicle.

Description

Technical Field

[0001] This invention begins with a method for recording event data in a vehicle. The subject matter also relates to an apparatus and a computer program product for performing such a method for recording event data in a vehicle, and to a computer-readable storage medium on which the computer program product is stored. Background Technology

[0002] Highly automated driving promises safer traffic due to the absence of human error. However, in such vehicles with highly automated driving capabilities, the need for data sensing increases in case of problems, providing all the necessary information for subsequent analysis and product improvement. Therefore, methods for recording event data are used in such vehicles. Here, vehicle data is continuously received from at least one vehicle system and written as event data into data frames of a pre-given size, wherein each data frame is stored in at least one volatile memory. The stored data frames are managed and kept available in at least one volatile memory until the event data stored in each data frame is older than a pre-given maximum previous event time point or is continuously stored in at least one non-volatile memory in response to a pre-given event being identified. The apparatus for performing such a method for recording event data typically includes a data providing component, an event recognition component, and a data recording component. Summary of the Invention

[0003] According to the present invention, a method for recording event data in a vehicle is proposed, wherein vehicle data is continuously received from at least one vehicle system and written as event data into data frames of a predetermined size, wherein each data frame is stored in at least one volatile memory, wherein the stored data frames are managed and remain available in the at least one volatile memory for an extended period of time until the event data stored in the respective data frames is older than a predetermined maximum previous event time point or is continuously stored in at least one non-volatile memory in response to a pre-defined event, wherein at least one partition of a predetermined size is set, and the received reference information of the respective data frames is written into the partition in an arbitrary temporal order, wherein a temporally randomly ordered subsequence of the written reference information of the respective data frames in the at least one partition is obtained and marked.

[0004] The method for recording event data in a vehicle according to the present invention has the advantage that the reference information of the individual data frames within a partition is not ordered, but stored in the order in which they arrive in time. The reference information of the individual data frames, or the individual data frames themselves, can arrive in any temporal order. Here, the data frames can originate from different data sources within the vehicle, such as those transmitting data via a vehicle network. Therefore, the data frames can be mutually corrected when providing data. However, it is very likely that the data frames typically arrive in a coarsely ordered manner. However, this is not guaranteed at all. Therefore, while the order of the data frames is arbitrary, a certain degree of randomness can be assumed. This means that embodiments of the present invention are based on the premise that the order of the data frames is not entirely random, but ordered to some extent, with some exceptions. The method according to the present invention for recording event data in a vehicle takes full advantage of this by remembering the randomly ordered subsequences within a partition, which later simplifies the search for data frames, which should be persistently stored in at least one non-volatile memory.

[0005] Therefore, in embodiments of the method for recording event data in a vehicle, data frames are not sorted because, during most driving, events do not occur for which vehicle data is continuously stored in at least one non-volatile memory. This means that for most driving times, data frames remain available in at least one volatile memory for only a defined period of time, and are discarded when event data stored in individual data frames is older than a pre-defined maximum previous event time. Thus, under normal circumstances, temporally sorting the reference information of individual data frames within a partition may be unnecessary. Furthermore, sorting data frames can lead to uneven implementation times, even when using extended sorting techniques.

[0006] Embodiments of the present invention provide a method for recording event data in a vehicle, wherein vehicle data is continuously received from at least one vehicle system and written as event data into data frames of a pre-given size. Each data frame is stored in at least one volatile memory, wherein the stored data frames are managed in at least one volatile memory and remain available for an extended period until the event data stored in each data frame is older than a pre-given maximum previous event time point or is continuously stored in at least one non-volatile memory in response to a pre-given event. Here, at least one partition of a pre-given size is provided, and the received reference information of each data frame is written into the partition in an arbitrary chronological order, wherein a subsequence of the written reference information of each data frame in the at least one partition is obtained and marked in a time-randomized order.

[0007] Furthermore, an apparatus is provided for performing a method for recording event data in a vehicle, the apparatus comprising a data providing component, a buffer block, an event recognition component, and a data recording component. The data providing component is configured to continuously receive vehicle data to be recorded from at least one vehicle system and write it as event data into data frames of a pre-given size, and store the respective data frames in at least one volatile memory. The buffer block is configured to manage the stored data frames and keep them available in at least one volatile memory until the event data stored in each data frame is older than a pre-given maximum previous event time point or is continuously stored in at least one non-volatile memory in response to a pre-given event identified by the event recognition component. Here, the buffer block includes a write function and at least one partition of a pre-given size, wherein the write function is configured to write the received reference information of each data frame into at least one partition in an arbitrary temporal order and to retrieve and mark a temporally randomly ordered subsequence of the written reference information of each data frame in the at least one partition.

[0008] It is also advantageous to have a computer program product with program code stored on a machine-readable medium such as semiconductor memory, hard disk memory or optical memory and used for analysis and utilization when the computer program is implemented.

[0009] Further measures and expansion schemes will lead to beneficial improvements to the method and device for recording event data in vehicles described above.

[0010] Currently, a data providing component can be understood as a processing unit that includes all processing steps from sensing raw vehicle data to organizing and storing the vehicle data as event data in volatile memory blocks, thereby ensuring that the event data remains available in at least one volatile memory for a limited period of time. Currently, an event recognition component can be understood as a processing unit that continuously monitors the vehicle's state and determines when a pre-configured situation or pre-given event occurs, requiring the continuous storage of pre-given vehicle data. Such a pre-given event may, for example, involve an identified functional failure in one of the vehicle systems or an identified collision between the vehicle and a stationary obstacle or other vehicle. Currently, a data recording component can be understood as a processing unit that includes processing steps to acquire usable vehicle data present in at least one volatile memory, perform possible further data transformations such as encryption, and ultimately continuously store the vehicle data in at least one non-volatile memory.

[0011] Therefore, the data providing component, event recognition component, and data recording component can each have at least one interface, which can be constructed in hardware and / or software. In the case of hardware construction, at least one interface can be, for example, part of a so-called system ASIC, which contains very different functions of the data providing component. However, it is also possible that the interface is a separate integrated circuit or at least partially composed of discrete structural elements. In the case of software construction, the interface can be a software module, which exists, for example, on a microcontroller alongside other software modules.

[0012] A data providing component can receive vehicle data to be recorded from at least one vehicle system via at least one interface. This at least one vehicle system may be implemented as an environmental sensing system, an occupant protection system, a driving power system, or a braking system. Furthermore, the data providing component can be connected to at least one volatile memory via at least one interface to ensure that the received vehicle data remains available in the at least one volatile memory for a limited period of time. Additionally, the data providing component may include further components for preparing and preprocessing the received vehicle data. An event recognition component can receive vehicle data or information from at least one vehicle system via at least one interface and analyze and utilize the received vehicle data or information to identify relevant events. Therefore, the data providing component or the event recognition component can be coupled, for example, to a vehicle data bus, thereby enabling the data providing component or the event recognition component to receive vehicle data and information from a large number of vehicle systems connected to the vehicle data bus.

[0013] The data recording component can be connected to at least one volatile memory via at least one interface to read data to be persistently stored. Furthermore, the data recording component can be connected to at least one non-volatile memory via at least one interface to store data to be persistently stored in at least one non-volatile memory.

[0014] Currently, a buffer block can be understood as a component that establishes a connection between a data providing component, an event recognition component, and a data recording component. Here, the buffer block keeps vehicle data provided by the data providing component in at least one volatile memory for such a long period that the data becomes too old and irrelevant to the event. In this case, the buffer block releases a memory area that has been used in at least one volatile memory for now-outdated vehicle data, so that the memory area can be reused by the data providing component to store updated vehicle data. Alternatively, the event recognition component notifies the buffer block that all vehicle data from a defined sensing time window should be provided to the data recording component for use. In this case, the buffer block ensures that all vehicle data within a pre-given current event time window remains available until the data recording component stores this vehicle data completely and continuously in at least one non-volatile memory. This also includes the extreme case where the data recording component stores vehicle data so slowly that the vehicle data for updated events becomes outdated during this period. In that case, the buffer block can also prevent the corresponding memory area in at least one volatile memory from becoming idle or overwrite it.

[0015] The data providing component, event recognition component, and data logging component can be distributed across multiple parts of the vehicle, interconnected via a suitable vehicle network infrastructure. For example, the data providing component can be implemented on multiple "data sources," such as a computing unit, which can forward vehicle data to other technical devices within the vehicle. These devices can perform event recognition and further post-processing steps and include buffer blocks, while the further post-processing steps and data storage can be implemented on another computing unit. Data providing, event recognition, and data logging can be implemented in separate processes. Furthermore, the device or hardware (implemented as a method for logging event data in a vehicle) can provide multiple CPU cores or processors, which can effectively implement these processes in parallel. Buffer blocks can separate calls made through the data logging component, event recognition component, and data providing component, ensuring that the result is always correct in each parallel implementation. Furthermore, the data providing component can invoke buffer blocks in multiple parallel processes. The data logging component is implemented in a single process; that is, the buffer block does not necessarily separate individual calls to the data logging component. The interface methods provided by the buffer block are called by the interface components and therefore run in their respective processes.

[0016] Particularly advantageous is that, in response to a request and according to at least one pre-defined reading criterion, reference information contained in at least one partition can be read and forwarded within a data frame. This pre-defined reading criterion includes at least one current event time window for which event data should be continuously recorded, and the data frame contains the event data to be continuously recorded. The data frame corresponding to the forwarded reference information can be continuously stored in at least one non-volatile memory.

[0017] In an advantageous configuration of the method, the start time of the current event time window can be predefined as a timestamp associated with the current zero reference time point. The end time of the current event time window can be predefined as the time difference relative to the start time point, wherein the current zero reference time point can be redefined if necessary. Here, the first zero reference time point may correspond to the vehicle's start time. The method for recording event data in the vehicle does not need to handle events that are temporally prior to the start of the current driving. Therefore, the zero reference time point does not necessarily need to be prior to the start of driving. For example, if the new current event time window cannot be represented using the current zero reference time point because the start time of the new current event time window is too far from the current zero reference time point, the current zero reference time point can be redefined. Typically, a time window can be represented as two absolute time points, that is, as two timestamps, a start timestamp and an end timestamp. 32 bits are needed to represent such a timestamp, and 64 bits are needed to represent the time window. A 32-bit processor can only read or write 32 bits atomically, that is, with machine instructions. Therefore, a 64-bit processor requires more than one machine instruction, which is not atomic. To represent the current event time window in 32 bits and to provide a lock-free, atomic implementation of the current event time window, a start timestamp is used for the start time point, and a time difference relative to the start time point or relative to the start timestamp is used for the end time point, instead of using two timestamps, the current event time window is defined. The length of the current event time window is expected to be in the minute range. That is, instead of storing two complete timestamps for the start and end times of the current event window, bits can be saved by simply storing the start timestamp and the duration of the event window. For example, the current event time window can be read or stored atomically with a 32-bit processor at a resolution of 0.1 seconds, where 17 bits are used for the start timestamp and 14 bits are used for the duration or length of the current event time window. Here, the start time of the current event time window can be represented, for example, within a maximum of 3.6 hours after the current zero reference time, and the duration or length of the current event time window can be represented within a maximum of 27.3 minutes or 1,638 seconds.

[0018] In another advantageous configuration of the method, each data frame can be associated with a time window. The reference information for each data frame can include a corresponding memory region and a corresponding time window with a start timestamp and an end timestamp for each data frame, in which at least one data segment containing event data that is generated or sensed is included in the corresponding data frame. Thus, it is simple and quick to verify whether a data frame contains event data or vehicle data whose generation or sensing overlaps with the current event time window. Furthermore, the start timestamp and end timestamp of each data frame can be associated with the current zero reference time point.

[0019] In another configuration of the method, a time window can be assigned to at least one partition. Here, the oldest start timestamp of the reference information contained in the partition of the corresponding data frame can be used as the start timestamp of the time window for the corresponding partition. The latest end timestamp of the reference information contained in the partition of the corresponding data frame can be used as the end timestamp of the time window for the corresponding partition. This allows for a simple and quick check whether the corresponding partition overlaps with the current event time window.

[0020] In another advantageous configuration of the method, reference information for at least one data frame can be read from at least one partition, the time window of which overlaps with the current event time window. Furthermore, the time window of at least one data frame in the reference information can become invalid after the reference information is read. This prevents the reference information of data frames from being read multiple times and the corresponding data frames from being continuously stored multiple times in at least one non-volatile memory.

[0021] In another advantageous configuration of the method, the reference information written to each data frame can be numbered in ascending order according to their writing sequence. Here, each time reference information for a new data frame is written, the time window of the new data frame can be compared with the time window of a data frame whose reference information was previously written as the last data frame to be written to the partition.

[0022] In another advantageous configuration of the method, for example, the start timestamp of a new data frame can be compared with the start timestamp of the last written data frame, wherein if the start timestamp of the new data frame is newer than the start timestamp of the last written data frame, the current start time subsequence, which is randomly ordered in time, is identified and continues. Alternatively, if the start timestamp of the new data frame is older than the start timestamp of the last written data frame, a new start time subsequence can be started and its start timestamp can be marked by storing the corresponding number of the new data frame. Furthermore, the first start time subsequence can begin with the start timestamp of the first written data frame. This means that the smallest number in the ascending order simultaneously marks the beginning of the current first start time subsequence, which is randomly ordered in time. Additionally or alternatively, the end timestamp of a new data frame can be compared with the end timestamp of the last written data frame, wherein if the end timestamp of the new data frame is newer than the end timestamp of the last written data frame, the current end time subsequence, which is randomly ordered in time, is identified. Alternatively, if the end timestamp of a new data frame is older than the end timestamp of the last data frame written, a new end timestamp subsequence can begin and its end timestamp can be marked by storing the corresponding number of the new data frame. Furthermore, the first end timestamp subsequence can begin with the end timestamp of the first data frame written. This means that the smallest number in the ascending sequence simultaneously marks the beginning of the current first end timestamp subsequence, which is randomly ordered in time. This may seem complex, but the number of timestamp comparisons during readout is significantly less than iterating through all data frames in a partition and checking their start and end timestamps.

[0023] In another advantageous configuration of the method, reference information for at least one data frame to be read from at least one partition can be obtained based on the temporal relationship between at least one temporally randomly ordered start time subsequence and / or at least one temporally randomly ordered end time subsequence of the currently read partition and the current event time window. Finding the reference information for the data frame to be read can be accelerated by importing the temporally randomly ordered start time subsequence and the temporally randomly ordered end time subsequence, because it is not always necessary to examine the reference information of all data frames contained in the currently read partition.

[0024] In another advantageous configuration of the method, to obtain reference information for a data frame to be read from at least one partition, if the start timestamp of the time window of at least one partition is outside the current event time window and the end timestamp of the time window of at least one partition is inside the current event time window, then a marked, temporally randomly ordered subsequence of end times is compared with the start time of the current event time window. In this case, the fewest partitions begin before the current event time window. Therefore, at least one partition contains data frames that are too old for the current event time window, but does not contain data frames that are too new for the current event time window. Therefore, it is sufficient to simply compare the end timestamps of each data frame with the start time of the current event time window. Using the marked, temporally randomly ordered subsequence of end times, starting with the end value of the first subsequence of end times, the end timestamps of the corresponding data frames are compared with the start time of the current event time window. This comparison is repeated for the next entry in the first subsequence of end times up to the initial value of the first subsequence of end times. This comparison is repeated for an extended period until the end timestamp of the currently examined data frame is earlier than the start time of the current event time window, or until the initial value of the first end time subsequence has been examined. Due to the ordering characteristics of the end time subsequences, all other "left-hand" data frames terminate earlier and therefore do not need to be considered. If the first end time subsequence has been examined, the process jumps to the end value of the next end time subsequence, and the comparison process restarts until all end time subsequences of at least one partition have been examined.

[0025] If the time window of at least one partition is completely within the current event time window, reference information in all data frames within at least one partition can be read. If the time window of at least one partition is completely within the current event time window, timestamps are not compared.

[0026] If the start timestamp of at least one partition's time window is within the current event time window and the end timestamp of at least one partition's time window is outside the current event time window, then to obtain the reference information to be read from at least one partition, the start timestamps of a marked, temporally randomly ordered subsequence of start times can be compared with the end time of the current event time window. In this case, at least one partition does not contain any data frames that are too old. Therefore, only the start timestamps of each data frame are compared with the end time of the current event time window to ensure that the data frames are not exactly after the current event time window in time. Using the marked, temporally randomly ordered subsequence of start times, starting with the initial value of the first subsequence of start times, the start timestamps of the corresponding data frames are compared with the end time of the current event time window. This comparison is repeated for the next entry in the first subsequence of start times until the end value of the first subsequence of start times. This comparison is repeated until the start timestamp of the currently examined data frame is after the end time of the current event time window or the end value of the first subsequence of start times has been examined. Due to the sorting characteristics of the start time subsequence, all other "more right" data frames start later and therefore do not need to be considered. If the first start time subsequence has been examined, the process jumps to the initial value of the next start time subsequence, and the comparison process restarts until all start time subsequences of at least one partition have been examined.

[0027] Furthermore, to obtain the reference information for a data frame to be read from at least one partition, if the start timestamp of the time window of at least one partition is older than the start time of the current event time window and the end timestamp of the time window of at least one partition is newer than the end time of the current event time window, then the start timestamps of the marked, time-randomized start time subsequences can be compared with the end time of the current event time window, and the end timestamps of the marked, time-randomized end time subsequences can be compared with the start time of the current event time window. In this case, at least one partition includes not only data frames that started before the current event time window but also data frames that ended after the current event time window. Therefore, both the start timestamp and the end timestamp of the data frame are checked. For this purpose, start time subsequences and end time subsequences are used to accelerate the retrieval of the data frame to be read.

[0028] In another advantageous configuration of the method, multiple partitions of a pre-given size can be set. Here, based on at least one write criterion, one of the partitions is designated as the current write partition, and the received reference information of each data frame is written into the current write partition. Responding to the request and based on at least one pre-given read criterion, one of the other partitions can be designated as the current read partition, the reference information contained in the data frame is read from the current read partition, and it is forwarded; the reference information contains event data to be continuously recorded. Here, the current write partition can be marked by a write partition pointer, and the current read partition can be marked by a read partition pointer. By having a unique current write partition—which only one function can exclusively access—other functions can be advantageously prevented from accessing the current write partition and changing its data content. The same applies to a unique read partition; only one function can exclusively access the unique read partition, so that no other function can access the current read partition and change its data content.

[0029] In another advantageous configuration of the method, an existing current event time window can be stored locally before determining the current read partition. Here, before each process of reading reference information from at least one data frame, the locally stored current event time window can be compared with the current event time window, and if the current event time window differs from the locally stored current event time window, the current event time window is stored locally. Furthermore, if the locally stored current event time window changes, it can be checked whether the time window of the current read partition overlaps with the new current event time window. If the current read partition overlaps with the changed current event time window, the read partition reading process can be restarted. This means that the current read partition is read again from the beginning. Here, the reference information that has already been read is no longer read because the time window of the corresponding data frame in the reference information becomes invalid after the reference information is read. Alternatively, if the current read partition does not overlap with the changed current event time window, a new current read partition can be determined. This means that the read process of the current read partition corresponding to the current read partition that has become outdated during this period is interrupted and does not restart. Therefore, at most, reference information for such a data frame is forwarded to the data recording component: the time window of the data frame is now outside the new current event time window. However, this behavior is as if the event recognition component defines the new current event time window only after reading the reference information of the data frame during the readout process, and is therefore tolerable.

[0030] In another advantageous configuration of the method, if the vehicle restarts or the current write partition is completely written with reference information, a new write partition can be searched according to at least one pre-given write criterion. For this purpose, for example, a set of partitions without a valid time window can be identified. This means that these partitions do not contain any reference information for data frames, thus avoiding a conflict between the determination of the current write partition and the current read partition. Because these partitions do not contain any reference information for data frames, and no attempt is made to use them as the current read partition, one of these partitions can be identified as the current write partition. Additionally or alternatively, partitions with a valid time window that is older than the largest previous event time point and does not overlap with an existing current event time window can be identified. This means that no future events require data frames for the corresponding partition, and the partition is not currently associated with a read partition, and not all reference information from data frames overlapping with the current event window has been read, even though they are past the largest previous event time point. From this group of partitions, partitions without a valid time window can be identified as the current write partition, or partitions whose corresponding valid time window has the oldest start timestamp can be selected. Furthermore, before determining the current write partition, the existing current event time window can be stored locally. Thus, before determining the current write partition, it can be checked whether the current event time window has changed. When a new current write partition is determined, the write partition pointer can be reset according to atomic machine instructions.

[0031] In an advantageous configuration of the device, the buffer block may include a read function that responds to a request from the data recording component and reads reference information contained in at least one partition of a data frame according to at least one pre-defined read criterion and forwards it to the data recording component. The read criterion includes at least one current event time window for which event data should be continuously recorded, and the reference information contains the event data to be recorded. The data recording component may be configured to continuously store data frames corresponding to the forwarded reference information in at least one non-volatile memory.

[0032] In another advantageous configuration of the device, the buffer block may include multiple partitions of a pre-given size, wherein the write function may be further configured to determine one of the partitions as the current write partition according to at least one write criterion, and write the reference information of each data frame received from the data providing component into the current write partition. The read function may be further configured to respond responsively to a request from the data recording component and determine one of the other partitions as the current read partition according to at least one pre-given read criterion, read the reference information contained in the data frame from the current read partition, and forward it to the data recording component.

[0033] In another advantageous configuration of the device, the event recognition component can be implemented to continuously monitor the state of the vehicle and determine when a pre-given event occurs, the pre-given event requiring the continuous storage of corresponding event data for at least one vehicle system. Here, the event recognition component is further implemented to output a current event time window corresponding to the recognized event to the buffer block, for which the event data should be continuously recorded, wherein the start time of the current event time window is not temporally preceding the largest previous event time point. Furthermore, the event recognition component can be further implemented to pre-given the start time of the current event time window as a timestamp associated with the current zero reference time point, and to pre-given the end time of the current event time window as a time difference relative to the start time point, wherein the buffer block can be implemented to redefine the current zero reference time point as needed. Attached Figure Description

[0034] Embodiments of the invention are shown in the accompanying drawings and explained in more detail in the following description. In the drawings, the same reference numerals denote components or elements that perform the same or similar functions.

[0035] Figure 1 A schematic flowchart illustrating an embodiment of a method according to the present invention for recording event data in a vehicle is shown.

[0036] Figure 2 Showing the use of in from Figure 1 A schematic diagram of an embodiment of a partitioning system according to the method of the present invention, which records event data in a vehicle.

[0037] Figure 3 Showing the use of in from Figure 1 Schematic illustrations of a first embodiment of the current event time window and several embodiments of the partitioned time window, which record event data in a vehicle according to the method of the present invention.

[0038] Figure 4Showing the use of in from Figure 1 A tabular diagram of the storage area in the vehicle that records event data according to the method of the present invention, during the redefinition of the current zero reference time point.

[0039] Figure 5 Showing the use of in from Figure 1 A schematic flowchart of a process for obtaining and labeling subsequences that are randomly ordered in time, according to the method of the present invention, for recording event data in a vehicle.

[0040] Figure 6 Showing the execution of the function from Figure 1 A schematic block diagram of an embodiment of a device according to the invention, which records event data in a vehicle according to the method of the invention. Detailed Implementation

[0041] from Figure 1 Obviously, in the illustrated embodiment of the method 100 according to the invention for recording event data in a vehicle, vehicle data from at least one vehicle system 3 is continuously received in step S100, and the vehicle data is written as event data into data frames DR of a pre-given size in step S110. In step S120, each data frame DR is stored in at least one volatile memory 50, wherein the stored data frame DR is managed and kept available in at least one volatile memory 50 until the event data stored in each data frame DR is older than a pre-given maximum previous event time point or is continuously stored in at least one non-volatile memory 46 in response to an identified pre-given event. For this purpose, at least one partition 21 of a pre-given size is set in step S130, and in step S140, the received reference information 25 of each data frame DR is written into the partition in an arbitrary chronological order. In step S150, a temporally randomly ordered subsequence of the written reference information 25 of each data frame DR in at least one partition 21 is obtained and marked.

[0042] In the embodiment of the method 100 according to the invention, in step S160, reference information 25 in event data contained in at least one partition 21 of a data frame DR is read and forwarded in response to a request and according to at least one pre-given reading criterion: the data frame contains event data to be continuously recorded, and the reading criterion includes at least one reference information in the data frame DR. Figure 3 The current event time window EZF shown indicates that event data should be continuously recorded for this current event time window. In step S170, the data frame DR corresponding to the forwarded reference information 25 is continuously stored in at least one non-volatile memory 46.

[0043] In the embodiment of the method 100 according to the invention, in step S130, a plurality of partitions 21 having a pre-given size are set, wherein, in step S135 (shown in dashed lines), one of these partitions 21 is determined as the current write partition according to at least one write criterion: in step S140, the received reference information 25 of each data frame DR is written into this partition. Furthermore, in the optional step S155 (shown in dashed lines), one of the other partitions 21 is determined as the current read partition in response to a request and according to at least one pre-given read criterion, which includes at least the current event window EZF for which event data should be continuously recorded. In step S160, the reference information 25 contained in the current read partition of such a data frame DR is then read and forwarded: the data frame DR contains event data to be continuously recorded.

[0044] In the illustrated embodiment, each data frame DR is associated with a time window 27. (As shown from...) Figure 2 It is further evident that the reference information 25 of each data frame DR includes a corresponding storage area, preferably indicated by the data frame pointer DRZ, and a corresponding time window 27 having a start timestamp 28 and an end timestamp 29 of each data frame DR, in which at least one data segment containing the generated or sensed event data is included in the corresponding data frame DR.

[0045] As from Figure 2 It is further evident that each partition 21 is equipped with a time window 22, wherein the oldest start timestamp 28 of the reference information 25 contained in the corresponding data frame DR within partition 21 is used as the start timestamp 23 of the time window 22 for the corresponding partition 21. The latest end timestamp 29 of the reference information 25 contained in the corresponding data frame DR within partition 21 is used as the end timestamp 24 of the time window 22 for the corresponding partition 21. (The text continues with further details about the time window 22 and its associated timestamps.) Figure 2 It is further evident that the illustrated fully written partition 21 includes reference information from fifteen data frames DR, each associated with a corresponding time window 27. The time window 22 of the illustrated partition 21 exemplarily has a value "3" for the start timestamp 28 of the first data frame DR, which corresponds to the oldest start timestamp 28 in the illustrated partition 21. As the end timestamp 24, the illustrated partition 21 exemplarily has a value "37" for the end timestamp 29 of the last data frame DR, which corresponds to the latest end timestamp 29 in the illustrated partition 21.

[0046] In the illustrated embodiment, the current event time window EZF is pre-defined. Figure 3 The start time point EZF_1 shown is used as the starting time point in the diagram. Figure 4 The timestamps associated with the current zero reference time point B are shown. The end time point EZF_2 of the current event time window EZF is pre-given as the time difference relative to the start time point EZF1, wherein the current zero reference time point B is redefined when necessary. For example, if the new current event time window EZF cannot be represented by the current zero reference time point B because the start time point EZF_1 of the new current event time window EZF is temporally far from the current zero reference time point, then the current zero reference time point B is redefined. Furthermore, the start timestamp 28 and end timestamp 29 of each data frame DR, and consequently the start timestamp 23 and end timestamp 24 of each partition 21, are associated with the current zero reference time B.

[0047] Subsequently, referring to Figure 4 This describes the procedure used to redefine the zero reference time B. For example, from... Figure 4 Obviously, the two final zero-reference time points A and B are stored in storage locations Epoch A and Epoch B, respectively. Within the current event time window EZF, the marker M in the corresponding storage location indicates which of the two stored zero-reference times A or B the start time point EZF_1 of the current event time window EZF is associated with. Typically, the oldest zero-reference time point corresponds to the vehicle's start time. In the illustrated embodiment, the current event time window EZF is encoded with 32 bits. Here, bits 0 to 13 represent the duration or length of the current event time window EZF, and bits 14 to 30 represent the time difference between the start time point EZF_1 of the current event time window EZF and the current zero-reference time window B. Bit 31 represents the marker for the currently valid zero-reference time point B. The validity of the zero reference time A stored in storage location Epoch A can be marked, for example, by a logical value "0", and the validity of the zero reference time point B stored in storage location Epoch B can be marked, for example, by a logical value "1". Figure 4 In the table, the second row shows the current state of the corresponding storage area. This means that the older first zero-reference time point A, with the exemplary value 2:00:00:000, is stored in storage location Epoch A, and the newer second zero-reference time point B, with the value 8:00:00:000, is stored in storage location Epoch B. The label M with the indicated value "B" indicates that the newer second zero-reference time point B stored in storage location Epoch B corresponds to the current zero-reference time point B. Here, the oldest zero-reference time point corresponds to the vehicle's start time.

[0048] As from Figure 4 It is further evident that, when redefining the currently used zero reference time point B, firstly, the older of the two stored zero reference time points A and B is overwritten with the new zero reference time point C. Figure 4 In the table, the third row shows this state of the corresponding storage region. This means that a new zero-reference time point C with the exemplary value 16:00:00:000 is stored in storage location Epoch A. Furthermore, an older second zero-reference time point B with the value 8:00:00:000 is stored in storage location Epoch B, where the marker M with the shown value "B" further indicates that the second zero-reference time point B stored in storage location Epoch B corresponds to the current zero-reference time point B. Then, in the atomic process, the new zero-reference time point C is marked as the current zero-reference time point C. Figure 4 In the table, the fourth row shows this state of the corresponding storage area. This means that a new zero-reference time point C with the exemplary value 16:00:00:000 is stored in storage location Epoch A. Furthermore, an older second zero-reference time point B with the value 8:00:00:000 is stored in storage location Epoch B, where the marker M with the shown value "A" now indicates that the new zero-reference time point C stored in storage location Epoch A now corresponds to the current zero-reference time point C. Next, a new current event time window EZF associated with the new current zero-reference time point C is atomically written. Figure 4 In the table, the fifth row shows the state of the corresponding storage area after the current zero reference time point C is redefined. The process for determining the current write partition, performed in step S135, according to the method of the invention for recording event data in a vehicle, is then described in more detail. Here, when the vehicle restarts or the current write partition is completely written with reference information 25, a new write partition is searched according to at least one pre-given write criterion. In the illustrated embodiment, the current event time window EZF, if present, is stored locally before determining the current write partition. The process determines a set of partitions 21 that do not have a valid time window 22 or have a valid time window that is completely older than the largest previous event time point and does not overlap with the existing current event time window EZF. From this set of partitions 21, partitions 21 that do not have a valid time window 22 or partitions 21 that have a corresponding valid time window 22 with the oldest start timestamp 23 are determined as the current write partition.

[0049] Subsequently, referring to Figure 5The process 160 for obtaining and labeling subsequences that are randomly ordered in time is described. Here, each time the reference information 25 of a new data frame DR is written, the time window 27 of the new data frame DR is compared with the time window 27 of a data frame DR that was previously written last to at least one partition.

[0050] As from Figure 5 Obviously, in step S200, after writing the reference information 25 of the new data frame DR, process 160 begins. In step S210, the reference information 25 written to each data frame DR is numbered in ascending order according to their writing order. Therefore, each partition 21 includes additional auxiliary information 60, such as from... Figure 2 Further, it can be seen that. Here, the reference information 25 written to each data frame DR includes number 62, which corresponds to... Figure 2 The reference information 25 of each data frame DR of partition 21 shown is numbered in ascending order according to their writing order.

[0051] In step S220, the start timestamp 28 in the reference information 25 of the new data frame DR is compared with the start timestamp 28 in the reference information 25 of the last written data frame DR. If the comparison in step S220 shows that the start timestamp 28 of the new data frame DR is newer than the start timestamp 28 of the last written data frame DR, then in step S230, the current start time subsequence 64, which is randomly ordered in time, is identified and continues to be processed. Then, process 160 continues with step S250. If the comparison in step S220 shows that the start timestamp 28 of the new data frame DR is older than the start timestamp 28 of the last written data frame DR, then in step S240, a new start time subsequence 64 is started and its start timestamp 28 is marked by storing the corresponding number 62 of the new data frame DR. Here, the first start time subsequence 64 begins with the start timestamp 28 of the first written data frame DR. Then, process 160 continues with step S250. Therefore, in Figure 2 The partition shown has an additional data area for displaying auxiliary information 60 related to a temporally randomly ordered subsequence of start times 64. For this purpose, the numbers of the initial values ​​of the temporally randomly ordered subsequence of start times 64 are stored in the additional data area.

[0052] As from Figure 2As can be further seen in the diagram, the exemplary partition 21 includes four start time subsequences 64. Here, the first start time subsequence 64 begins with the smallest number "0" in ascending order number 62. The second start time subsequence 64 begins with the number "3" in ascending order number 62 because the start timestamp 28 of the corresponding data frame DR with the value "5" is older than the start timestamp 28 of the previous data frame 62 with the value "7". The third start time subsequence 64 begins with the number "7" in ascending order number 62 because the start timestamp 28 of the corresponding data frame DR with the value "7" is older than the start timestamp 28 of the previous data frame DR with the value "13". The fourth start time subsequence 64 begins with the number "13" in ascending order number 62 because the start timestamp 28 of the corresponding data frame DR with the value "28" is older than the start timestamp 28 of the previous data frame DR with the value "29".

[0053] In step S250, the end timestamp 29 of the new data frame DR is compared with the end timestamp 29 of the last written data frame DR. If the comparison in step S250 shows that the end timestamp 29 of the new data frame DR is newer than the end timestamp 29 of the last written data frame DR, then in step S260, the current end time subsequence 66, which is randomly ordered in time, is identified and continues to be processed. Then, process 160 terminates in step S280. If the comparison in step S250 shows that the end timestamp 29 of the new data frame DR is older than the end timestamp 29 of the last written data frame DR, then in step S270, a new end time subsequence 64 begins and its end timestamp 29 is marked by storing the corresponding number 62 of the new data frame DR. Here, the first end time subsequence 66 begins with the end timestamp 29 of the first written data frame DR. Then, process 160 terminates in step S280. Therefore, in Figure 2 The partition shown has an additional data area for displaying auxiliary information 60, which is related to a temporally randomly ordered subsequence of end times 66. For this purpose, the numbers of the initial values ​​of the obtained temporally randomly ordered subsequence of end times 66 are stored in the additional data area.

[0054] As from Figure 2It is further evident that the exemplary partition 21 comprises five end-time subsequences 66. Here, the first end-time subsequence 66 begins with the smallest number "0" in ascending order 62. The second end-time subsequence 66 begins with the number "1" because the end timestamp 29 of the corresponding data frame DR with the value "19" is older than the end timestamp 29 of the previous data frame DR with the value "20". The third end-time subsequence 66 begins with the number "5" because the end timestamp 29 of the corresponding data frame DR with the value "19" is older than the end timestamp 29 of the previous data frame DR with the value "27". The fourth end-time subsequence 66 begins with the number "7" because the end timestamp 29 of the corresponding data frame DR with the value "12" is older than the end timestamp 29 of the previous data frame DR with the value "30". The fifth end time subsequence 66 begins with the number "11" because the end timestamp 29 of the corresponding data frame DR with the value "25" is older than the end timestamp 29 of the previous data frame DR with the value "28".

[0055] In the embodiment of the method 100 according to the invention, reference information 25 of at least one data frame DR to be read from the current read partition is obtained based on the temporal relationship of at least one temporally randomly ordered start time subsequence 64 and / or at least one temporally randomly ordered end time subsequence 66 of the current read partition with respect to the current event time window EZF.

[0056] Figure 3 Four time windows 22A, 22B, 22C, and 22D of partition 21 are shown exemplarily, which overlap with the current event time window EZF. Because all the shown time windows 22A, 22B, 22C, and 22D overlap with the current event time window EZF, all corresponding partitions 21 are suitable to be identified as the current read partition. Because the time windows 22A, 22B, 22C, and 22D of the current read partition overlap with the current event time window EZF, at least one data frame DR of the current read partition also overlaps with the current event time window EZF. Reference information 25 for at least one data frame DR is read from such a current read partition: the time window 27 of the current read partition overlaps with the current event time window EZF. Here, after reading the reference information 25, the time window 27 of at least one data frame DR in the reference information 25 becomes invalid.

[0057] As from Figure 3It is further evident that the start timestamp 23 of the first time window 22 of the corresponding partition 21 is outside the current event time window EZF, and the end timestamp 24 of the first time window 22 of the corresponding partition 21 is within the current event time window EZF. Therefore, partition 21 may contain data frames DR that are too old for the current event time window EZF, but not data frames DR that are too new for the current event time window EZF. Therefore, in order to obtain the reference information 25 for the data frames DR to be read from partition 21, only the end timestamp 29 of the data frames DR of the marked, time-randomly ordered end time subsequence 66 is compared with the start time point EZF_1 of the current event time window EZF to identify the data frames DR that are completely before the current event time window EZF.

[0058] Subsequently, for the current event time window EZF with a start time point EZF1 having a value of "25" and an end time point EZF2 having a value of "40", the reference information 25 is illustrated exemplarily from... Figure 2 The reading process of partition 21 shown is a first time window 22A with a start timestamp 23 having a value of "3" and an end timestamp 24 having a value of "37".

[0059] Here, the first randomly ordered first end time subsequence 66, which has only one entry with the number "0", is examined. To do this, the end timestamp 29 of the data frame DR with the number "0" is read from the corresponding reference information 25. This end timestamp has the value "20" and is compared with the start time EZF_1 of the current event time window EZF, which is "25". Because the end timestamp 29 with the value "20" is older than the start time EZF_1 of the current event time window EZF, the corresponding data frame with the number "0" is too old for both the start timestamp 28 ("3") and the end timestamp 29 ("20"), causing the corresponding reference message 25 to not be forwarded. Since the first end time subsequence 66 does not contain any other entries for data frames, the examination of the first end time subsequence 66 is complete.

[0060] Next, the randomly ordered second end time subsequence 66 is examined, which has four entries with numbers "1", "2", "3", and "4". For this purpose, the end timestamp 29 of the data frame DR with number "4", which has a value "27" and corresponds to the last entry of the second end time subsequence 66, is first read from the corresponding reference information 25 and compared with the start time EZF_1 of the current event time window EZF, which is "25". Because the end timestamp 29 with value "27" is newer than the start time EZF_1 of the current event time window EZF, which is "25", the corresponding data frame DR with number "4" overlaps with the current event time window EZF, thus the corresponding reference information 25 is forwarded and the data frame DR with number "4" is continuously stored. Furthermore, the time window 27 in the reference information 25 of the data frame DR with number "4" in partition 21 is deleted. Then, the end timestamp 29 with the value "22" is read from the reference information 25 corresponding to the next entry, namely the data frame DR with the number "3", and compared with the start time EZF_1 of the current event time window EZF, which is "25". Because the end timestamp 29 with the value "22" is older than the start time EZF_1 of the current event time window EZF, which is "25", the corresponding data frame DR with the number "3" is too old, and therefore the corresponding reference information 25 is not forwarded. Because the other entries of the data frame DR with the numbers "2" and "1" in the second end time subsequence 66 also have older end timestamps 29 with the values ​​"20" or "19" due to random sorting, the inspection of the second end time subsequence 66 ends.

[0061] Next, the randomly ordered third end time subsequence 66, which has two entries with numbers "5" and "6", is examined. For this purpose, the end timestamp 29 of the data frame DR with number "6", having a value of "30" and corresponding to the last entry of the third end time subsequence 66, is first read from the corresponding reference information 25 and compared with the start time EZF_1 of the current event time window EZF, which is "25". Because the end timestamp 29 with a value of "30" is newer than the start time EZF_1 of the current event time window EZF, the corresponding data frame DR with number "6" overlaps with the current event time window EZF, thus the corresponding reference information 25 is forwarded and the data frame DR with number "6" is continuously stored. Furthermore, the time window 27 in the reference information 25 of the data frame DR with number "6" in partition 21 is deleted. Then, the end timestamp 29 with the value "19" is read from the reference information 25 corresponding to the next entry, namely the data frame DR with the number "5", and compared with the start time EZF_1 of the current event time window EZF, which is "25". Because the end timestamp 29 with the value "19" is older than the start time EZF_1 of the current event time window EZF, the corresponding data frame DR with the number "5" is too old, and therefore the corresponding reference information 25 is not forwarded. Since the third end time subsequence 66 does not contain any other entries for the data frame DR, the inspection of the third end time subsequence 66 ends.

[0062] Next, the randomly ordered fourth end time subsequence 66, which has four entries with numbers "7", "8", "9", and "10", is examined. For this purpose, the end timestamp 29 of the data frame DR with number "10", having a value "28" and corresponding to the last entry of the fourth end time subsequence 66, is first read from the corresponding reference information 25 and compared with the start time EZF_1 of the current event time window EZF, which is "25". Because the end timestamp 29 with value "28" is newer than the start time EZF_1 of the current event time window EZF, the corresponding data frame DR with number "10" overlaps with the current event time window EZF, thus the corresponding reference information 25 is forwarded and the data frame DR with number "10" is continuously stored. Furthermore, the time window 27 in the reference information 25 of the data frame DR with number "10" in partition 21 is deleted. Then, the end timestamp 29 with the value "23" is read from the reference information 25 corresponding to the next entry, namely the data frame DR with the number "9", and compared with the start time EZF_1 of the current event time window EZF, which is "25". Because the end timestamp 29 with the value "23" is older than the start time EZF_1 of the current event time window EZF, the corresponding data frame DR with the number "9" is too old, and therefore the corresponding reference information 25 is not forwarded. Because the other entries of the data frames DR with the numbers "8" and "7" in the fourth end time subsequence 66 also have older end timestamps 29 with the values ​​"19" or "20" due to random sorting, the inspection of the fourth end time subsequence 66 ends.

[0063] Next, the randomly ordered fifth end time subsequence 66, which has four entries with numbers "11", "12", "13", and "14", is examined. For this purpose, the end timestamp 29 of the data frame DR with number "14", having a value of "37" and corresponding to the last entry of the fifth end time subsequence 66, is first read from the corresponding reference information 25 and compared with the start time EZF_1 of the current event time window EZF, which is "25". Because the end timestamp 29 with a value of "37" is newer than the start time EZF_1 of the current event time window EZF, the corresponding data frame DR with number "14" also overlaps with the current event time window EZF, thus the corresponding reference information 25 is forwarded and the data frame DR with number "14" is continuously stored. Furthermore, the time window 27 in the reference information 25 of the data frame DR with number "14" in partition 21 is deleted. Then, the end timestamp 29 with the value "35" is read from the reference information 25 corresponding to the next entry, namely the data frame DR with the number "13", and compared with the start time EZF_1 of the current event time window EZF, which is "25". Because the end timestamp 29 with the value "35" is older than the start time EZF_1 of the current event time window EZF, the data frame DR with the number "13" overlaps with the current event time window EZF, so the corresponding reference information 25 is forwarded and the data frame DR with the number "13" is continuously stored. In addition, the time window 27 in the reference information 25 of the data frame DR with the number "13" in partition 21 is deleted. Then, the end timestamp 29 with the value "33" is read from the reference information 25 corresponding to the next entry, namely the data frame DR with the number "12", and compared with the start time EZF_1 of the current event time window EZF, which is "25". Because the end timestamp 29 with the value "33" is newer than the start time EZF_1 of the current event time window EZF which is "25", the corresponding data frame DR with number "12" overlaps with the current event time window EZF, so the corresponding reference information 25 is forwarded and the data frame DR with number "12" is continuously stored. Furthermore, the time window 27 in the reference information 25 of the data frame DR with number "12" in partition 21 is deleted. Then, the end timestamp 29 with the value "25" is read from the reference information 25 of the next entry, namely the data frame DR with number "11", and compared with the start time EZF1 of the current event time window EZF which is "25".Because the end timestamp 29 with the value "25" corresponds to the start time point EZF_1 of the current event time window EZF with the value "25", the corresponding data frame DR with the number "11" also overlaps with the current event time window EZF. Therefore, the corresponding reference information 25 is forwarded and the data frame DR with the number "11" is continuously stored. Furthermore, the time window 27 in the reference information 25 of the data frame DR with the number "11" in partition 21 is deleted. Because the fifth end time subsequence 66 does not contain any additional entries for the data frame DR, the examination of the fifth end time subsequence 66 is terminated. Because partition 21 does not contain any additional randomly ordered end time subsequence 66, the examination of partition 21 is terminated overall.

[0064] As is evident from this example, the retrieval and labeling of the randomly ordered end time subsequence 66 performs at least one unsuccessful comparison of the end timestamp 29 of the data frame DR with the start time EZF_1 of the current event time window EZF. This is more than in a fully ordered partition 21, depending on the number of end time subsequences 66 present. However, in general, this is better than having no information on the end time subsequences 66. In the example above, only four data frame DRs are unsuccessfully checked, even though the exemplary partition 21 contains eight too old data frame DRs. In other words, unnecessary checks on four data frame DRs are avoided by using the end time subsequence 66.

[0065] As from Figure 3 It is further evident that the start timestamp 23 and end timestamp 24 of the second time window 22B of the corresponding partition 21 are within the current event time window EZF. Therefore, partition 21 does not contain data frame DRs that are too old for the current event time window EZF, nor does it contain data frame DRs that are too new for the current event time window EZF. As a result, the reference information 25 of all data frame DRs in the corresponding partition 21 is read out and forwarded without further verification, and the corresponding data frame DRs are continuously stored.

[0066] As from Figure 3It is further evident that the start timestamp 28 of the third time window 22C of the corresponding partition 21 is within the current event time window EZF, and the end timestamp 29 of the third time window 22C of the corresponding partition 21 is outside the current event time window EZF. Therefore, partition 21 can contain data frames DR that are too new for the current event time window EZF, but does not contain data frames DR that are too old for the current event time window EZF. Therefore, in order to obtain the reference information 25 to be read from partition 21 for data frames DR, only the start timestamp 28 of the marked, time-randomly ordered start time subsequence 64 is compared with the end time point EZF_2 of the current event time window EZF to identify data frames DR that are completely after the current event time window EZF.

[0067] Subsequently, for the current event time window EZF with a start time point EZF_1 having a value of "1" and an end time point EZF_2 having a value of "10", the reference information 25 is illustrated exemplarily. Figure 2 The readout process in partition 21 shown has a third time window 22C with a start timestamp 23 having a value of "3" and an end timestamp 24 having a value of "37".

[0068] Here, the first randomly ordered first start time subsequence 64, which has three entries with numbers "0", "1", and "2", is examined first. For this purpose, the start timestamp 28 of the data frame DR with number "0", which has a value "3", is read from the corresponding reference information 25 and compared with the end time point EZF_2 of the current event time window EZF, which is "10". Because the start timestamp 28 with a value "3" is older than the end time point EZF_2 of the current event time window EZF, which is "10", the corresponding data frame DR with number "0" overlaps with the current event time window EZF, thus the corresponding reference information 25 is forwarded and the data frame DR with number "0" is continuously stored. Furthermore, the time window 27 in the reference information 25 of the data frame DR with number "0" in partition 21 is deleted. Then, the start timestamp 28 with a value of "4" is read from the reference information 25 corresponding to the next entry, namely the data frame DR with number "1", and compared with the end time point EZF_2 of the current event time window EZF, which is "10". Because the start timestamp 28 with a value of "4" is older than the end time point EZF_2 of the current event time window EZF, the corresponding data frame DR with number "1" also overlaps with the current event time window EZF, so the corresponding reference information 25 is forwarded and the data frame DR with number "1" is continuously stored. In addition, the time window 27 in the reference information 25 of the data frame DR with number "1" in partition 21 is deleted. Then, the start timestamp 28 with a value of "7" is read from the reference information 25 corresponding to the next entry, namely the data frame DR with number "2", and compared with the end time point EZF_2 of the current event time window EZF, which is "10". Because the start timestamp 28 with the value "7" is older than the end time EZF_2 of the current event time window EZF which is "10", the corresponding data frame DR with the number "2" also overlaps with the current event time window EZF. Therefore, the corresponding reference information 25 is forwarded and the data frame DR with the number "2" is continuously stored. Furthermore, the time window 27 in the reference information 25 of the data frame DR with the number "2" in partition 21 is deleted.

[0069] Next, the randomly ordered second start time subsequence 64, which has four entries with numbers "3", "4", "5", and "6", is examined. For this purpose, the start timestamp 28 of the data frame DR with number "3", having a value of "5", is read from the corresponding reference information 25 and compared with the end time point EZF_2 of the current event time window EZF, which is "10". Because the start timestamp 28 with a value of "5" is older than the end time point EZF_2 of the current event time window EZF, the corresponding data frame DR with number "3" overlaps with the current event time window EZF, thus the corresponding reference information 25 is forwarded and the data frame DR with number "3" is continuously stored. Furthermore, the time window 27 in the reference information 25 of the data frame DR with number "3" in partition 21 is deleted. Then, the start timestamp 28 with a value of "6" is read from the reference information 25 corresponding to the next entry, namely the data frame DR with number "4", and compared with the end time EZF_2 of the current event time window EZF, which is "10". Because the start timestamp 28 with a value of "6" is older than the end time EZF_2 of the current event time window EZF, the corresponding data frame DR with number "4" overlaps with the current event time window EZF, so the corresponding reference information 25 is forwarded and the data frame DR with number "4" is continuously stored. In addition, the time window 27 in the reference information 25 of the data frame DR with number "4" in partition 21 is deleted. Then, the start timestamp 28 with a value of "9" is read from the reference information 25 corresponding to the next entry, namely the data frame DR with number "5", and compared with the end time EZF_2 of the current event time window EZF, which is "10". Because the start timestamp 28 with the value "9" is older than the end time EZF_2 of the current event time window EZF (which is "10"), the corresponding data frame DR with number "5" overlaps with the current event time window EZF. Therefore, the corresponding reference information 25 is forwarded, and the data frame DR with number "5" is continuously stored. Furthermore, the time window 27 in the reference information 25 of the data frame DR with number "5" in partition 21 is deleted. Then, the start timestamp 28 with the value "13" is read from the reference information 25 of the next entry, namely the data frame DR with number "6," and compared with the end time EZF_2 of the current event time window EZF (which is "10"). Because the start timestamp 28 with the value "13" is newer than the end time EZF_2 of the current event time window EZF (which is "10"), the corresponding data frame DR with number "6" is too new, and therefore the corresponding reference information 25 is not forwarded.Since the second start time subsequence 64 does not contain any additional entries for the data frame DR, the examination of the second start time subsequence 64 is terminated. Next, the randomly ordered third start time subsequence 64, which has six entries with numbers "7", "8", "9", "10", "11", and "12", is examined. For this purpose, the start timestamp 28 of the data frame DR with number "7" is read from the corresponding reference information 25, and this start timestamp has the value "7" and is compared with the end time point EZF_2 of the current event time window EZF, which is "10". Because the start timestamp 28 with the value "7" is older than the end time point EZF_2 of the current event time window EZF, the corresponding data frame DR with number "7" overlaps with the current event time window EZF, so the corresponding reference information 25 is forwarded and the data frame DR with number "7" is continuously stored. Furthermore, the time window 27 in the reference information 25 of the data frame DR with number "7" in partition 21 is deleted. Then, the start timestamp 28 with the value "14" is read from the reference information 25 corresponding to the next entry, namely the data frame DR with the number "8", and compared with the end time point EZF_2 of the current event time window EZF, which is "10". Because the start timestamp 28 with the value "14" is newer than the end time point EZF_2 of the current event time window EZF, the corresponding data frame DR with the number "8" is too new, and therefore the corresponding reference information 25 is not forwarded. Because the other entries of the data frames DR with the numbers "9", "10", "11", and "12" in the third start time subsequence 64 only have newer start timestamps 28 with the numbers "15", "19", "23", or "29" due to random sorting, the inspection of the third start time subsequence 64 ends.

[0070] Next, the randomly ordered fourth start time subsequence 64 is examined, which has two entries with numbers "13" and "14". For this purpose, the start timestamp 28 of the data frame DR with number "13" is read from the corresponding reference information 25, having a value of "28", and compared with the end time point EZF_2 of the current event time window EZF, which is "10". Because the start timestamp 28 with value "28" is newer than the end time point EZF_2 of the current event time window EZF, which is "10", the corresponding data frame DR with number "13" is too new, and therefore the corresponding reference information 25 is not forwarded. The examination of the fourth start time subsequence 64 ends because the other entry in the data frame DR with number "14" in the fourth start time subsequence 64 has a more recent start timestamp 28 of "31" due to random ordering.

[0071] As is evident from this example, the retrieval and marking of the start timestamp 28 of the data frame DR for the randomly ordered start time subsequence 64 results in at least one unsuccessful comparison with the end time point EZF_1 of the current event time window EZF. This is more than in a fully ordered partition 21, depending on the number of start time subsequences 64. However, in general, this is better than having no information about the start time subsequences 64. In the example above, only three data frame DRs were unsuccessfully checked, even though the exemplary partition 21 contains eight too-new data frame DRs. In other words, five unnecessary checks of data frame DRs are saved by using the start time subsequence 64.

[0072] As from Figure 3 It is further evident that the start timestamp 28 and end timestamp 29 of the fourth time window 22D of the corresponding partition 21 are located outside the current event time window EZF. Therefore, the corresponding partition 21 may contain data frames DR that are too new for the current event time window EZF and data frames DR that are too old for the current event time window EZF. Therefore, in order to obtain the reference information 25 to be read from partition 21 for data frames DR, the start timestamp 28 of the marked, time-randomized start time subsequence 64 is compared with the end time point EZF_2 of the current event time window EZF to identify data frames DR that are completely after the current event time window EZF. In addition, the end timestamp 29 of the marked, time-randomized end time subsequence 66 is compared with the start time point EZF_1 of the current event time window EZF to identify data frames DR that are completely before the current event time window EZF.

[0073] Here, a randomly ordered end time subsequence 66 is first used to find data frames DR that are not entirely before the event time window EZF. To do this, the end timestamp 29 of the last entry of the data frame DR in the first randomly ordered end time subsequence 66 is first compared with the start time EZF1 of the current event time window EZF to check whether the data frame DR in the first randomly ordered end time subsequence 66 is entirely before the event time window EZF. If so, the process continues with the next randomly ordered end time subsequence 66, and the reference information 25 of the data frame DR in the first randomly ordered end time subsequence 66 is not forwarded. If not, the end timestamp 29 of the data frame DR in the first randomly ordered end time subsequence 66 is checked starting with the first entry to find data frames DR that are not entirely before the event time window EZF, because earlier entries of the data frame DR in the randomly ordered first end time subsequence 66 may be even older than the current event time window EZF. After obtaining the number of the first such data frame DR, a corresponding randomly ordered start time subsequence 64 is found, which contains the first data frame DR. To ensure that the data frame DR is not completely after the event time window EZF, the start timestamp 28 of the first randomly ordered start time subsequence 64 is compared with the end time point EZF_2 of the current event time window EZF, starting with the start timestamp 28 of the obtained first data frame DR, to find a data frame DR that is completely after the event time window EZF. If a data frame DR that is completely after the current event time window EZF is found, the process continues with the first entry of the next randomly ordered start time subsequence 64. Furthermore, each time a data frame DR overlapping with the current event time window EZF is found, it is checked whether the found data frame DR also belongs to the previously checked randomly ordered end time subsequence 66. If so, the reference information 25 of the found data frame DR is forwarded and the time window 27 in the reference information 25 of the data frame DR in partition 21 is deleted. Otherwise, the process continues with a randomly ordered end time subsequence 66, to which the found data frame DR belongs.

[0074] Subsequently, for the current event time window EZF with a start time point EZF_1 having a value of "5" and an end time point EZF_2 having a value of "15", reference information 25 is illustrated exemplarily from... Figure 2 The readout process in partition 21 shown has a fourth time window 22D with a start timestamp 23 of value "3" and an end timestamp 24 of value "37".

[0075] Here, the first randomly ordered first end time subsequence 66, which has only one entry with the number "0", is examined. For this purpose, the end timestamp 29 of the data frame DR with the number "0" is read from the corresponding reference information 25, and this end timestamp has the value "20". It is then compared with the start time point EZF_1 of the current event time window EZF, which has the value "25". Because the end timestamp 29 with the value "20" is newer than the start time point EZF_1 of the current event time window EZF, which has the value "5", the corresponding data frame DR with the number "0" is not exactly before the current event time window EZF. Since the first end time subsequence 66 does not contain any additional entries for the data frame DR, the process continues with the examination of the first start time subsequence 64, which has three entries with the numbers "0", "1", and "2", and the data frame DR with the number "0" belongs to this first start time subsequence. Therefore, the start timestamp 28 of the data frame DR with number "0" is read from the corresponding reference information 25. This start timestamp has a value of "3" and is compared with the end time point EZF_2 of the current event time window EZF, which has a value of "15". Because the start timestamp 28 with a value of "3" is older than the end time point EZF_2 of the current event time window EZF, the corresponding data frame DR with number "0" overlaps with the current event time window EZF. Thus, the corresponding reference information 25 is forwarded and the data frame DR with number "0" is continuously stored. Furthermore, the time window 27 in the reference information 25 of the data frame DR with number "0" in partition 21 is deleted.

[0076] Next, the start timestamp 28 with the value "4" is read from the reference information 25 corresponding to the next entry, namely the data frame DR with the number "1", and compared with the end time EZF_2 "15" of the current event time window EZF. Although the start timestamp 28 with the value "4" is older than the end time EZF_2 of the current event time window EZF with the value "15", and thus the data frame DR with the number "1" is not exactly after the current event time window EZF, the data frame DR with the number "1" no longer belongs to the first end time subsequence 66 of the verified random order.

[0077] Therefore, the process continues with a randomly ordered second end time subsequence 66, which has four entries with numbers "1", "2", "3", and "4". For this purpose, the end timestamp 29 of the data frame DR with number "4", having a value "27" and corresponding to the last entry of the second end time subsequence 66, is read from the corresponding reference information and compared with the start time EZF_1 of the current event time window EZF, which has a value "5". Because the end timestamp 29 with a value "27" is newer than the start time EZF_1 of the current event time window EZF, the corresponding data frame DR with number "4" is not completely positioned before the current event time window EZF, thus further verifying the randomly ordered second end time subsequence 66, and the process continues with the first entry of the randomly ordered second end time subsequence 66.

[0078] Therefore, the end timestamp 29 of the data frame DR with number "1" is read from the corresponding reference information 25. This end timestamp has the value "19" and corresponds to the first entry of the second end time subsequence 66, and is compared with the start time point EZF_1 of the current event time window EZF with the value "5". Because the end timestamp 29 with the value "19" is newer than the start time point EZF_1 of the current event time window EZF with the value "5", the corresponding data frame DR with number "1" is not completely arranged before the current event time window EZF. Due to the random ordering of the second end time subsequence 66, this also applies to the end timestamps 29 of the data frame DRs with numbers "2" and "3". Because the checked start timestamp 28 of the data frame DR with number "1" with the value "4" is not arranged after the current event time window EZF, the data frame DR with number "1" overlaps with the current event time window EZF, so the corresponding reference information 25 is forwarded and the data frame DR with number "1" is continuously stored. Furthermore, time window 27 in reference information 25 for data frame DR with number "1" in partition 21 is deleted. Next, the start timestamps 28 of data frames with numbers "2", "3", and "4", having values ​​"7", "5", and "6", are successively examined from the corresponding reference information 25 and compared with the end time point EZF_2 of the current event time window EZF, which has a value of "15". Because the start timestamps 28 of data frame DRs with numbers "2", "3", and "4" are all older than the end time point EZF_2 of the current event time window EZF, which has a value of "15", the corresponding data frame DRs with numbers "2", "3", and "4" overlap with the current event time window EZF, thus the corresponding reference information 25 is forwarded and the data frame DRs with numbers "2", "3", and "4" are continuously stored. Furthermore, time window 27 in reference information 25 for data frame DRs with numbers "2", "3", and "4" in partition 21 is deleted.

[0079] Next, the start timestamp 28 with the value "9" is read from the reference information 25 corresponding to the next entry in the randomly ordered second start time subsequence 64, which is the data frame DR with the number "5", and compared with the end time point EZF_2 with the value "15" in the current event time window EZF. Although the start timestamp 28 with the value "9" is older than the end time point EZF_2 with the value "15" in the current event time window EZF, and thus the data frame DR with the number "5" is not exactly after the current event time window EZF, the data frame DR with the number "5" no longer belongs to the examined, randomly ordered second end time subsequence 66.

[0080] Therefore, the process continues with a randomly ordered third end time subsequence 66, which has two entries with numbers "5" and "6". To this end, the end timestamp 29 of the data frame DR with number "6", having a value "30" and corresponding to the last entry of the second end time subsequence 66, is first read from the corresponding reference information 25 and compared with the start time EZF_1 "5" of the current event time window EZF. Because the end timestamp 29 with value "30" is newer than the start time EZF_1 "5" of the current event time window EZF, the corresponding data frame DR with number "4" is not completely positioned before the current event time window EZF, thus further verifying the randomly ordered third end time subsequence 66, and the process continues with the first entry of the randomly ordered second end time subsequence 66.

[0081] Therefore, the end timestamp 29 of the data frame DR with number "5" is read from the corresponding reference information 25. This end timestamp has the value "19" and corresponds to the first entry of the third end time subsequence 66, and is compared with the start time EZF1 "5" of the current event time window EZF. Because the end timestamp 29 with the value "19" is newer than the start time EZF_1 "5" of the current event time window EZF, the corresponding data frame DR with number "5" is not completely arranged before the current event time window EZF. Because the verified start timestamp 28 of the data frame DR with number "5" with the value "9" is not arranged after the current event time window EZF, the data frame DR with number "5" overlaps with the current event time window EZF, so the corresponding reference information 25 is forwarded and the data frame DR with number "5" is continuously stored. In addition, the time window 27 in the reference information 25 of the data frame DR with number "5" in partition 21 is deleted. Next, the start timestamp 28 of the data frame DR with number "6" is examined from the corresponding reference information 25. This start timestamp has a value of "13" and is compared with the end time point EZF_2 "15" of the current event time window EZF. Because the start timestamp 28 of the data frame DR with number "6" is older than the end time point EZF_2 of the current event time window EZF, the corresponding data frame DR with number "6" overlaps with the current event time window EZF. Therefore, the corresponding reference information 25 is forwarded and the data frame DR with number "6" is continuously stored. Furthermore, the time window 27 in the reference information 25 of the data frame DR with number "6" in partition 21 is deleted.

[0082] Next, the start timestamp 28 with the value "7" is read from the reference information 25 corresponding to the next entry in the randomly ordered third start time subsequence 64, namely the data frame DR with the number "7", and compared with the end time EZF_2 of the current event time window EZF with the value "15". Although the start timestamp 28 with the value "7" is older than the end time EZF_2 of the current event time window EZF with the value "15", and thus the data frame DR with the number "7" is not exactly after the current event time window EZF, the data frame DR with the number "7" no longer belongs to the examined, randomly ordered third end time subsequence 66.

[0083] Therefore, the process continues with a randomly ordered fourth end time subsequence 66, which has four entries with numbers "7", "8", "9", and "10". To this end, the end timestamp 29 of the data frame DR with number "10", having a value "28" and corresponding to the last entry of the fourth end time subsequence 66, is first read from the corresponding reference information 25 and compared with the start time EZF_1 of the current event time window EZF, which has a value "5". Because the end timestamp 29 with a value "28" is newer than the start time EZF_1 of the current event time window EZF, the corresponding data frame DR with number "10" is not completely positioned before the current event time window EZF, thus further verifying the randomly ordered fourth end time subsequence 66, and the process continues with the first entry of the randomly ordered fourth end time subsequence 66.

[0084] Therefore, the end timestamp 29 of the data frame DR with number "7" is read from the corresponding reference information 25. This end timestamp has the value "12" and corresponds to the first entry of the fourth end time subsequence 66, and is compared with the start time point EZF_1 of the current event time window EZF, which has the value "5". Because the end timestamp 29 with the value "12" is newer than the start time point EZF_1 of the current event time window EZF, which has the value "5", the corresponding data frame DR with number "7" is not completely positioned before the current event time window EZF. Due to the random ordering of the second end time subsequence 66, this also applies to the end timestamps 29 of the data frames DR with numbers "8" and "9". Because the verified start timestamp 28 of the data frame DR with number "7" is not placed after the current event time window EZF, the data frame DR with number "7" overlaps with the current event time window EZF, thus the corresponding reference information 25 is forwarded and the data frame DR with number "7" is continuously stored. Furthermore, the time window 27 in the reference information 25 of the data frame DR with number "7" in partition 21 is deleted. Next, the start timestamps 28 of the data frames DR with numbers "8", "9", and "10", which have values ​​"14", "15", and "16", are sequentially read from the corresponding reference information 25 and compared with the end time point EZF_2 of the current event time window EZF, which has a value of "15". Because the start timestamp 28 of the data frame DR with numbers "8" and "9" is not updated compared to the end time EZF_2 of the current event time window EZF with value "15", the corresponding data frame DR with numbers "8" and "9" overlaps with the current event time window EZF. Therefore, the corresponding reference information 25 is forwarded and the data frame DR with numbers "8" and "9" is continuously stored. Furthermore, the time window 27 in the reference information 25 of the data frame DR with numbers "8" and "9" in partition 21 is deleted. Because the start timestamp 28 of the data frame with number "10" and value "19" is updated compared to the end time EZF_2 "15" of the current event time window EZF, the corresponding data frame DR with number "10" is too new, and therefore the corresponding reference information 25 is not forwarded. Because the additional entries of data frame DR with numbers “11” and “12” in the third start time subsequence 64 have updated start timestamps 28 “23” and “29” due to random sorting, the additional entries of data frame DR with numbers “11” and “12” are not forwarded and the inspection of the third start time subsequence 64 ends.

[0085] Next, the process continues with a randomly ordered fourth start time subsequence 64, which has two entries with numbers "13" and "14". For this purpose, the start timestamp 28 with the value "28" is read from the reference information 25 corresponding to the first entry, i.e., the data frame DR with number "13", and compared with the end time EZF_2 "15" of the current event time window EZF. Because the start timestamp 28 with the value "19" of the data frame DR with number "13" is newer than the end time EZF_2 "15" of the current event time window EZF, the corresponding data frame DR with number "13" is too new, and therefore the corresponding reference information 25 is not forwarded. Since the other entry in the fourth start time subsequence 64 with number "14" has a more updated start timestamp 28 "31" due to random ordering, the other entry in the data frame DR with number "14" is also not forwarded, and the verification of the fourth start time subsequence 64 ends. Therefore, the examination of partition 21 is also complete. This may seem complicated, but the number of comparisons performed on start timestamp 28 and end timestamp 29 is significantly less than the examination of all start timestamp 28 and all end timestamp 29 of the data frame DR contained in the partition.

[0086] Before determining the current read partition, the existing current event time window EZF is stored locally. Specifically, before each readout of reference information 25 from at least one data frame DR, the locally stored current event time window EZF is compared with the current event time window EZF. Here, if the current event time window EZF differs from the locally stored current event time window EZF, the previously stored current event time window EZF is stored locally. Furthermore, if the locally stored current event time window EZF has changed, it is checked whether the current read partition's time window 22 overlaps with the new current event time window EZF. If the current read partition overlaps with the changed current event time window EZF, the readout process restarts. Alternatively, if the current read partition does not overlap with the changed current event time window EZF, a new current read partition is determined.

[0087] The implementation of method 100 according to the present invention can be implemented, for example, in software or hardware or in a hybrid form consisting of software and hardware.

[0088] As is evident from Figure 7, the illustrated embodiment of the apparatus 1 according to the invention for performing the method 100 for recording event data in a vehicle includes a data providing component 10, a buffer block 20, an event recognition component 30, and a data recording component 40. The data providing component 10 continuously receives vehicle data to be recorded from at least one vehicle system 3 and writes this vehicle data as event data into data frames DR of a pre-given size, and writes each data frame DR into at least one volatile memory 50. The buffer block 20 manages the stored data frames DR and keeps these data frames available in at least one volatile memory 50 until the event data stored in each data frame DR is more than a pre-given maximum previous event time point or a pre-given event identified by the event recognition component 30, and is continuously stored reactively in at least one non-volatile memory 46. Here, the buffer block 20 includes a write function SF and at least one partition 21 of a pre-given size. The write function SF writes the received reference information 25 of each data frame DR into at least one partition 21 in an arbitrary time order and retrieves and marks the time-randomly ordered subsequences of the written reference information 25 of each data frame DR in at least one partition 21.

[0089] In the illustrated embodiment, buffer block 20 includes a plurality of partitions 21 having a pre-given size. According to at least one write criterion, write function SF identifies one of the partitions 21 as the current write partition and writes the reference information 25 received from data providing component 10 for each data frame DR into the current write partition. Furthermore, in the illustrated embodiment, buffer block 20 includes read function LF. Responding to a request from data recording component 40 and according to at least one pre-given read criterion, which includes at least one current event time window EZF for which event data should be continuously recorded, read function LF identifies one of the other partitions 21 as the current read partition, reads the reference information 25 contained in the current read partition for the data frame DR containing the event data to be continuously recorded, and forwards this reference information to data recording component 40. Data recording component 40 continuously stores the data frame DR corresponding to the forwarded reference information 25 in at least one non-volatile memory 46.

[0090] The event recognition component 30 continuously monitors the vehicle's status and determines when a pre-defined event will occur, requiring the continuous storage of corresponding event data for at least one vehicle system 3. The event recognition component 30 outputs the current event time window (EZF) corresponding to the recognized event to the cache block 20. For this event time window, event data should be continuously recorded, wherein the start time of the current event time window (EZF) is not earlier than the maximum time point.

[0091] In the illustrated embodiment, the first vehicle system 3 is implemented as an environmental sensing system 3A. The second vehicle system 3 is implemented as an occupant protection system 3B, the third vehicle system 3 is implemented as a driving dynamics system 3C, and the fourth vehicle system is implemented as a braking system 3D. It goes without saying that vehicle data from other vehicle systems or other combinations of the aforementioned vehicle systems 3 can also be sensed and recorded.

[0092] Event recognition component 30 pre-assigns the start time EZF_1 of the current event time window EZF as a timestamp related to the current zero reference time point B, and pre-assigns the end time EZF_2 of the current event time window EZF as the time difference relative to the start time point EZF_1. Buffer block 20 redefines the current zero reference time point B when needed.

[0093] In the illustrated embodiment, the data providing component 10 includes data sensing 12 and data preprocessing, and delivers reference information 25 of data frames DR stored in at least one volatile memory 50 to a buffer block 20. As implemented above, in the illustrated embodiment, the reference information 25 of each data frame DR includes a data frame pointer DRZ pointing to the storage location of a data block or data frame stored in the volatile memory, and a corresponding time window 27 of the data frame DR having a start timestamp 26 and an end timestamp 29. Upon detection of an event, the buffer block 20 forwards the corresponding reference information 25 of the data frame that should be continuously stored in at least one non-volatile memory 46 to the data recording component 40. In the illustrated embodiment, the data recording component 40 includes data post-processing 42, data storage 44, and at least one non-volatile memory 46. Each data frame DR typically contains more than one data segment, which is generated or stored within the time window 27 of the data frame DR. The buffer block 20 only knows the time window 27 of the data frame DR and does not know or understand the content of the data frame DR. Buffer block 20 receives data frames DR from data providing component 10 as a reference and forwards them to data recording component 40. This means that buffer block 20 does not copy the stored contents of data frames DR. If event identification component 30 notifies buffer block 20 of the current event time window EZF, buffer block 20 identifies the data frame DR associated with the current event time window EZF. Buffer block 20 then provides the data recording component 40 with reference information 25 for such data frame DR that it overlaps temporally with the current event time window EZF for data recording purposes. This means that buffer block 20 forwards the complete reference information 25 of the data frame DR to data recording component 40, even if the data frame DR only partially overlaps with the current event time window EZF and therefore some data segments may be outside the current event time window EZF. Buffer block 20 only associates data frame DRs with events that have temporal overlap with the current event time window EZF. Buffer block 20 does not use additional criteria to assign data frame DRs to events. Buffer block 20 provides reference information 25 of data frames DR that overlap with the current event time window EZF to data recording component 40. Buffer block 20 forwards data frames DR to data recording component 40 in a specific order, without any restrictions on that order. Buffer block 20 processes only one event at a time. Event identification component 30 only notifies buffer block 20 of the current event time window EZF. Buffer block 20 does not require additional knowledge about the event's status or details. If event identification component 30 identifies a second event while buffer block 20 is already processing the current event time window EZF of the first event, event identification 30 may change the current event time window EZF.Furthermore, buffer block 20 has a static, i.e., compile-time known, configurable limit indicating how many time units before the current event time window EZF can begin. This limit is called the maximum preceding event time point. Event identification component 30 cannot change the start of the current event time window EZF to a time point that is temporally before the maximum preceding event time point. Furthermore, event identification component 30 cannot specify a current event time window EZF whose start is temporally before the maximum preceding event time point.

[0094] Therefore, the behavior of buffer block 20 is indicated by the current event time window (EZF). If event recognition component 30 senses an event for which data must be continuously recorded, it notifies buffer block 20 of the corresponding current event time window (EZF), which corresponds to a time period for which the corresponding data frame (DR) should be continuously stored. The current event time window (EZF) may end at a future point in time. If another event is identified, the current event time window (EZF) may change. This could be the case, for example, if a less significant event is first identified, followed by a more serious event considered to be associated with the first event. An example might be that a vehicle crosses the center line of the road (i.e., a malfunction exists in the vehicle's automatic steering function) as event A, and then the airbag controller notifies event recognition component 30 of airbag deployment as a consequence of a frontal collision as event B. Event A can be considered independently as crucial for recording vehicle data within a current first event time window EZF, which has a start time EZF_1 10 seconds before event A and an end time EZF_2 10 seconds after event A. Event B is significantly more serious than event A, and event B may require recording vehicle data within a current second event time window EZF, which has a start time EZF_1 30 seconds before event B and an end time EZF2 30 seconds after event B. That is, while recording vehicle data for event A is still in progress, the event recognition component 30 changes the current event time window EZF for recording vehicle data for event B.

[0095] In the illustrated embodiment, from the outside, buffer block 20 corresponds to a set of pointers DRZ pointing to data frames DR: buffer block 20 retains the data frames for a period of time until either it returns them to the memory management of at least one volatile memory 50 or forwards them to a data recording component 40, which reads the data frames DR corresponding to the forwarded pointers DRZ from at least one volatile memory 50 and persistently stores them in at least one non-volatile memory 46. The current write partition can be marked with atomic machine instructions, for example, a write partition pointer. Internally, the buffer block includes a row of partitions 21. A single partition 21 corresponds, for example, to an array of data frame pointers DRZ: these data frame pointers are supplemented with additional information 26 related to a time window 27 of the corresponding data frame DR and auxiliary information 60 that simplifies and speeds up the reading process of reference information 25. The size and number of partitions 21 in buffer block 20 are statically configurable (i.e., known at compile time). Buffer block 20 statically contains the memory region of partition 21, meaning that buffer block 20 statically allocates partition 21 when the program starts. The size and number of partitions 21 can be configured such that the number of data frame pointers (DRZs) is sufficient under all conditions. In addition to partition 21 containing the data frame pointers (DRZs), buffer block 20 contains a concrete representation of the current event time window (EZF).

[0096] The data providing component 10 embeds the reference information 25 of the corresponding data frame DR into the buffer block 20, while the data recording component 40 reads the reference information 25 of the data frame DR from the buffer block 20, and the corresponding data frame DR is continuously stored. Therefore, here, the data providing component 10 is referred to as a "writer" and the data recording component 40 is referred to as a "reader". The writer and the reader can call the program of the buffer block 20 simultaneously or in parallel from different processes, and the internal state of the buffer block 20 naturally remains correct in all possible simultaneous or parallel processes.

[0097] Buffer block 20 separates the write process of the write function SF from the read process of the read function LF by exclusively occupying partition 21. Buffer block 20 identifies one of the partitions 21 as the current "write partition". The write function SF exclusively occupies the current write partition. The read function LF can neither read from nor modify the current write partition, even if the current write partition contains a data frame DR that overlaps temporally with the current event time window EZF. If the write function SF completely fills the current write partition with reference information 25, the write function SF searches for a new current write partition using the determination process described above, and the write partition up to this point becomes accessible to the read function LF.

[0098] When the write function SF determines the new current write partition, it resets the write partition pointer of buffer block 20 according to the atomic storage procedure. This eliminates a race condition that could result from the read function LF accessing an outdated cache version of the current write partition, such as in the CPU cache of another CPU core.

[0099] Similarly, the read function LF has partition 21, which is determined as the current read partition. Naturally, the current read partition overlaps temporally with the current event time window EZF; otherwise, the read function LF would not be interested in the contained data frames DR. Due to the determination process described above, the write function SF will never access the current read partition unless there is another means to separate the processes. If the read function LF reads all the reference information 25 of the relevant data frames DR from the current read partition, then the time window 22 of the current read partition is either invalid because all data frames DR contained in the current read partition have been read, or the time window 22 of the current read partition no longer overlaps with the current event time window EZF. The read function LF then searches for other partitions that overlap with the current event time window EZF and are not the current write partition. If the read function LF finds such a partition 21 because the buffer block contains multiple reference information 25 of data frames DR related to the current event, then the read function LF determines this partition 21 as the new current read partition. Because the write function SF never accesses the currently read partition, atomically storing the read partition pointer is not necessary. In the majority of calls to buffer block 20, the write function SF simply appends reference information 25 about the new data frame DR to the end of the current write partition, thereby potentially extending the time window 22 of the current write partition. Similarly, the read function LF simply reads reference information 25 about the next data frame DR from the current read partition. In this way, the write function SF and the read function LF never interfere with each other. Simultaneous access to the partition may only occur when the current write partition has been completely written or the current read partition has been completely read. However, these are write-protected read-only accesses that compare the time windows 22 of partition 21. Based on the definition of a new exclusive read partition or a new exclusive write partition, the read process and the write process are always separated as specified.

[0100] There may be more than one call to the write function SF. To avoid race conditions caused by two calls that simultaneously define a new current write partition or want to overwrite state information within the current write partition, all accesses to buffer block 20 are implemented by the call to the write function SF only if a lock is exclusively held. If there is only one unique write function SF, the lock is always available during a single atomic read. Otherwise, a second call must wait until the currently active write function SF unlocks the lock. This is a better solution than actions performed under a lock, which are very fast, compared to importing separate current write partitions individually with each call to the write function SF. Note that neither the read function LF nor the event recognition component 30 needs to acquire the lock at all times. This means that if two calls here simultaneously embed the reference information 25 of the new data frame DR into buffer block 20 via the write function SF, the lock only causes a waiting period.

[0101] Event identification can be implemented as a separate process within the event identification component 30. The event identification component 30 does not directly interact with the processing of the data frame DR. However, the event identification component 30 can define, modify, or invalidate the current event time window stored in the buffer block 20 at any time. The write function SF reads the current event time window EZF when searching for a new write partition. Although the simultaneous access to the current event time window by the event identification component 30 and the write function SF is "merely" a read / write conflict, the buffer block 20 ensures that the write function SF does not read a partially written and therefore arbitrarily corrupted current event time window EZF, while the event identification component 30 modifies the current event time window EZF. If there are more than one call to the write function SF, only one of them can acquire the described exclusive lock. Therefore, for simultaneous access to the current event time window EZF, only one write function SF may be in conflict with the event identification component 30, while other calls attempt to acquire the lock. Buffer block 20 resolves the conflict between the event recognition component 30 and the write function SF by storing the current event time window EZF as an atomic value, i.e., as machine instructions. Therefore, the event recognition component 30 writes a new current event time window EZF in a single atomic process. The write function SF either reads the old current event time window EZF or reads the new current event time window EZF, but never reads a corrupted, partially written current event time window EZF.

[0102] When searching for a new write partition, the write function SF first creates a locally running copy of the current event time window EZF using an atomic read process. Then, the write function SF works solely with this locally running copy until a new write partition is found. In this way, it is possible that the write function SF searches for a new write partition using an outdated current event time window EZF. However, this behavior is the same as in cases where the write function SF first updates the write partition and the event recognition component 30 then changes the current event time window EZF.

[0103] In the event of a described read / write conflict between the event identification component 30 and the write function SF, the read function LF also experiences a read / write conflict with the event identification component 30 for accessing the current event time window EZF of buffer block 20. The read function LF must know the current event time window EZF in order to find the partition 21 containing the data frame DR that overlaps with the current event time window EZF, and, if the partition 21 is not fully contained within the current event time window EZF, to identify or determine the relevant data frame DR within that partition. Naturally, the read function LF will not read a partially written, corrupted current event time window EZF, while the event identification component 30 simultaneously modifies the current event time window EZF.

[0104] As implemented above, the event recognition component 30 atomically updates the current event time window EZF. Similarly, the read function LF atomically reads the current event time window EZF at the start of each program call to buffer block 20 and stores it in a locally run copy. During the read process, the read function LF uses this copy wherever the current event time window EZF is needed.

[0105] It is possible that the current event time window EZF stored in buffer block 20 differs from the locally executed copy of the read function LF. The read function LF terminates the current read process with the current event time window EZF becoming outdated during this period, and thus forwards the reference information 25 of such data frame DR to the data recording component 40 to the maximum extent possible: the time window 22 of the data frame is outside the current event time window EZF. However, this behavior is as if the event recognition component 30 specifies a new current event time window EZF only after the read function LF has processed the data frame DR, and is therefore tolerable.

[0106] At the start of each call to buffer block 20, the read function LF not only creates a locally running copy of the current event time window EZF, but also checks whether the current event time window EZF has changed since the previous call. If the current event time window EZF has changed, the read function LF first checks whether the current read partition still overlaps with the new current event time window. If this is not the case, the read function LF searches for a new current read partition, as explained above. If the current read partition always overlaps with the new current event time window EZF, the read function LF restarts the read process and rereads the current read partition from the beginning.

Claims

1. A method (100) for recording event data in a vehicle, wherein, Vehicle data is continuously received from at least one vehicle system (3) and written as event data into data frames (DRs) of a pre-given size, wherein each data frame (DR) is stored in at least one volatile memory (50), wherein the stored data frames (DRs) are managed and remain available in the at least one volatile memory (50) for such a long period of time that the event data stored in each data frame (DR) is older than a pre-given maximum previous event time point or is continuously stored in at least one non-volatile memory (46) in response to a pre-given event, wherein at least one partition (21) of a pre-given size is set, wherein the received reference information (25) of each data frame (DR) is written into the partition in an arbitrary time order, wherein a temporally randomly ordered subsequence of the written reference information (25) of each data frame (DR) in the at least one partition (21) is obtained and marked.

2. The method (100) according to claim 1, characterized in that, Responding to a request and reading and forwarding reference information (25) contained in the at least one partition (21) such a data frame (DR) according to at least one pre-given reading criterion: the data frame contains event data to be continuously recorded, and the data frame (DR) corresponding to the forwarded reference information (25) is continuously stored in the at least one non-volatile memory (46), wherein the at least one pre-given reading criterion includes at least one current event time window (EZF) for which the event data should be continuously recorded.

3. The method (100) according to claim 2, characterized in that, The start time (EZF_1) of the current event time window (EZF) is pre-defined as a timestamp associated with the current zero reference time point (B), and the end time (EZF_2) of the current event time window (EZF) is pre-defined as the time difference relative to the start time point (EZF_1), wherein the current zero reference time point (B) is redefined as needed.

4. The method (100) according to claim 3, characterized in that, The oldest zero reference time point corresponds to the vehicle's start-up time point.

5. The method (100) according to claim 3 or 4, characterized in that, If the new current event time window (EZF) cannot be represented by the current zero reference time point (B) because the start time point (EZF_1) of the new current event time window (EZF) is too far from the current zero reference time point (B) in time, then the current zero reference time point (B) is redefined.

6. The method (100) according to any one of claims 1 to 4, characterized in that, Each data frame (DR) is associated with a time window (27), wherein the reference information (25) of each data frame (DR) includes a corresponding storage area and a corresponding time window (27) having the start timestamp (28) and end timestamp (29) of each data frame (DR), and at least one data segment of the event data generated or sensed in the time window is included in the corresponding data frame (DR).

7. The method (100) according to claim 6, characterized in that, The start timestamp (28) and end timestamp (29) of each data frame (DR) are associated with the current zero reference time point (B).

8. The method (100) according to claim 6, characterized in that, A time window (22) is assigned to the at least one partition (21), wherein the oldest start timestamp (28) of the reference information (25) contained in the partition (21) of the corresponding data frame (DR) is used as the start timestamp (23) of the time window (22) of the corresponding partition (21), and wherein the latest end timestamp (29) of the reference information (25) contained in the partition (21) of the corresponding data frame (DR) is used as the end timestamp (24) of the time window (22) of the corresponding partition (21).

9. The method (100) according to claim 8, characterized in that, Reference information (25) of at least one data frame (DR) is read from the at least one partition (21), the time window (27) of the at least one data frame overlaps with the current event time window (EZF), wherein the reference information (25) of the data frame has been read, and the time window (27) of at least one data frame (DR) becomes invalid in the corresponding reference information (25) after the readout.

10. The method (100) according to any one of claims 1 to 4, characterized in that, The reference information (25) written to each data frame (DR) is numbered in ascending order according to the writing order of the reference information.

11. The method (100) according to claim 10, characterized in that, Each time a new data frame (DR) reference information (25) is written, the time window (27) of the new data frame (DR) is compared with the time window (27) of such a data frame (DR) whose reference information (25) was previously written as the last reference information into the at least one partition.

12. The method (100) according to claim 11, characterized in that, The start timestamp (28) of the new data frame (DR) is compared with the start timestamp (28) of the last written data frame (DR). If the start timestamp (28) of the new data frame (DR) is newer than the start timestamp (28) of the last written data frame (DR), the current start timestamp subsequence (64) is identified and continues to be randomly ordered in time. Alternatively, if the start timestamp (28) of the new data frame (DR) is older than the start timestamp (28) of the last written data frame (DR), a new start timestamp subsequence (64) is started and the start timestamp (28) of the data frame is marked by storing the corresponding number (62) of the new data frame (DR). The first start timestamp subsequence (64) begins with the start timestamp (28) of the first written data frame (DR).

13. The method (100) according to claim 11 or 12, characterized in that, The end timestamp (29) of the new data frame (DR) is compared with the end timestamp (29) of the last written data frame (DR). If the end timestamp (29) of the new data frame (DR) is newer than the end timestamp (29) of the last written data frame (DR), the current end timestamp subsequence (66) is identified and continues to be randomly ordered in time. Alternatively, if the end timestamp (29) of the new data frame (DR) is older than the end timestamp (29) of the last written data frame (DR), a new end timestamp subsequence (66) is started and the end timestamp (29) of the new end timestamp subsequence is marked by storing the corresponding number (62) of the new data frame (DR). The first end timestamp subsequence (66) begins with the end timestamp (29) of the first written data frame (DR).

14. The method (100) according to claim 13, characterized in that, Based on the temporal relationship between at least one temporally randomly ordered start time subsequence (64) and / or at least one temporally randomly ordered end time subsequence (66) of the currently read partition and the current event time window (EZF), obtain reference information (25) for at least one data frame (DR) to be read from said at least one partition.

15. The method (100) according to claim 14, characterized in that, In order to obtain the reference information (25) to be read from the at least one partition (21) of the data frame (DR), if the start timestamp (23) of the time window (22A) of the at least one partition (21) is outside the current event time window (EZF) and the end timestamp (24) of the time window (22A) of the at least one partition (21) is inside the current event time window (EZF), the end timestamp (29) of the marked time-randomly ordered end time subsequence (66) is compared with the start time point (EZF_1) of the current event time window (EZF).

16. The method (100) according to claim 14 or 15, characterized in that, If the time window (22B) of the at least one partition (21) is completely within the current event time window (EZF), read the reference information (25) of all data frames (DR) in the at least one partition (21).

17. The method (100) according to claim 14 or 15, characterized in that, In order to obtain the reference information (25) to be read from the at least one partition (21) of the data frame (DR), if the start timestamp (23) of the time window (22C) of the at least one partition (21) is within the current event time window (EZF) and the end timestamp (24) of the time window (22C) of the at least one partition (21) is outside the current event time window (EZF), the start timestamp (28) of the marked time-randomized start time subsequence (64) is compared with the end time point (EZF_2) of the current event time window (EZF).

18. The method (100) according to claim 14 or 15, characterized in that, In order to obtain the reference information (25) to be read from the at least one partition (21) of the data frame (DR), if the start timestamp (23) of the time window (22D) of the at least one partition (21) is older than the start time (EZF_1) of the current event time window (EZF) and the end timestamp (24) of the time window (22D) of the at least one partition (21) is newer than the end time (EZF_2) of the current event time window (EZF), then the start timestamp (28) of the marked time-randomized start time subsequence (64) is compared with the end time (EZF_2) of the current event time window (EZF), and the end timestamp (29) of the marked time-randomized end time subsequence (66) is compared with the start time (EZF_1) of the current event time window (EZF).

19. The method (100) according to any one of claims 1 to 4, characterized in that, Multiple partitions (21) with a pre-given size are set up, wherein one of the partitions (21) is determined as the current write partition according to at least one write criterion, and the received reference information (25) of each data frame (DR) is written into the current write partition.

20. The method (100) according to claim 19, characterized in that, In response to the request and based on at least one pre-given reading criterion, one of the other partitions (21) is identified as the current reading partition, and the reference information (25) contained in the data frame (DR) is read from and forwarded.

21. The method (100) according to claim 20, characterized in that, Before determining the current read partition, an existing current event time window (EZF) is stored locally, wherein, before each readout process of reference information (25) of at least one data frame (DR), the locally stored event time window (EZF) is compared with the current event time window (EZF), and if the current event time window is different from the locally stored event time window (EZF), the current event time window (EZF) is stored locally, wherein, if the locally stored event time window (EZF) has changed, it is checked whether the time window (22) of the current read partition and the changed event time window (EZF) overlap, and wherein, if the time window of the current read partition overlaps with the changed event time window (EZF), the readout process of the read partition is restarted, or, if the time window of the current read partition does not overlap with the changed event time window (EZF), a new current read partition is determined.

22. The method (100) according to claim 19, characterized in that, If the vehicle restarts or the currently written partition is completely written with reference information, search for a new written partition based on at least one pre-given write criterion.

23. The method (100) according to claim 22, characterized in that, A set of partitions (21) is determined, wherein the partitions do not have a valid time window (22) or have a valid time window (22) that is older than the largest previous event time point and does not overlap with the existing current event time window (EZF), wherein the partitions (21) without a valid time window (22) or the partitions (21) that are determined from this set of partitions (21) are determined as the current write partitions: the corresponding valid time window (22) of the partition has the oldest start timestamp (23).

24. An apparatus (1) for performing a method for recording event data in a vehicle according to any one of claims 1 to 23, the apparatus comprising a data providing component (10), a buffer block (20), an event recognition component (30), and a data recording component (40), wherein, The data providing component (10) is configured to continuously receive vehicle data to be recorded from at least one vehicle system (3) and write it as event data into data frames (DRs) of a pre-given size and store each data frame (DR) in at least one volatile memory (50), wherein the buffer block (20) is configured to manage the stored data frames (DRs) and keep these data frames available in the at least one volatile memory (50) until the event data stored in the respective data frames (DRs) is older than a pre-given maximum previous event time point or is identified by the event. The component (30) continuously stores the pre-given events identified in response in at least one non-volatile memory (46), wherein the buffer block (20) includes a write function (SF) and at least one partition (21) of a pre-given size, wherein the write function (SF) is implemented to write the received reference information (25) of each data frame (DR) into the at least one partition (21) in an arbitrary time order, and to obtain and mark a temporally randomly ordered subsequence of the written reference information (25) of each data frame (DR) in the at least one partition (21).

25. The device (1) according to claim 24, characterized in that, The buffer block (20) includes a read function (LF) configured to respond to a request from the data recording component (40) and read the reference information (25) of the data frame (DR) contained in the at least one partition (21) according to at least one pre-given read criterion and forward it to the data recording component (40), wherein the read criterion includes at least one current event time window (EZF) for which event data should be recorded, the data recording component contains the event data to be recorded, and wherein the data recording component (40) is configured to persistently store the data frame (DR) corresponding to the forwarded reference information (25) in the at least one non-volatile memory (46).

26. The device (1) according to claim 25, characterized in that, The buffer block (20) includes a plurality of partitions (21) having a pre-given size, wherein the write function (SF) is further configured to determine one of the partitions (21) as the current write partition according to at least one write criterion, and to write reference information (25) of each data frame (DR) received from the data providing component (10) into the current write partition, and wherein the read function (LF) is further configured to respond to a request from the data recording component (40) and determine one of the other partitions (21) as the current read partition according to the at least one pre-given read criterion, to read the reference information (25) contained in the data frame (DR) from the current read partition and forward it to the data recording component (40).

27. The device (1) according to any one of claims 24 to 26, characterized in that, The event recognition component (30) is configured to continuously monitor the state of the vehicle and determine when a pre-given event occurs, the pre-given event requiring the continuous storage of corresponding event data of the at least one vehicle system (3), wherein the event recognition component (30) is further configured to output the current event time window (EZF) corresponding to the recognized event to the buffer block (20), the event data for the current event time window should be continuously recorded, wherein the start time of the current event time window (EZF) is not located before the maximum previous event time point in time.

28. The device (1) according to claim 27, characterized in that, The event recognition component (30) is further configured to pre-assign the start time (EZF_1) of the current event time window (EZF) as a timestamp related to the current zero reference time point (EZF), and pre-assign the end time (EZF_2) of the current event time window (EZF) as a time difference relative to the start time point (EZF_1), wherein the buffer block (20) is configured to redefine the current zero reference time point (B) when necessary.

29. A computer program product configured to implement a method for recording event data in a vehicle according to any one of claims 1 to 23.

30. A computer-readable storage medium on which the computer program product of claim 29 is stored.

Images