Methods for modeling dead time behavior

Abstract

Method for modeling dead time behavior in a forward operating mode (I) and in a reverse operating mode (II), wherein in forward operation (I) memory cells (S1, S2, ..., Sm, Sn) of a memory (14) are selected successively in a first sequence (R1) by means of a write pointer (SZ) to write values ​​(W1, W2, Wm, ..., Wn) into the memory cells (S1, S2, ..., Sm, Sn), and are selected by means of a read pointer (LZ) to read the values ​​(W1, W2, Wm, ..., Wn) from the memory cells (S1, S2, ..., Sm, Sn), wherein in reverse operation (II) the memory cells (S1, S2, ..., Sm, Sn) of the memory (14) are selected successively in a second sequence (R2) by means of the write pointer (SZ) to write values ​​(W1, W2, Wm, ..., Wn) into the memory cells (S1, S2, ..., Sm, Sn), and are selected by means of the read pointer (LZ) to read the values ​​(W1, W2, Wm, ..., Wn) from the memory cells (S1, S2, ..., Sm, Sn), where the first sequence (R1) has a different direction of progress than the second sequence (R2), where the reading pointer (LZ) is determined depending on the writing pointer (SZ), where, to switch from an output operating mode to a target operating mode, the write pointer (SZ) of the target operating mode is set to the last value of the read pointer of the output operating mode.

Description

[0001] The present invention relates to a method for modeling dead time behavior, a control unit and a computer program. State of the art

[0002] Dead time behavior is very common in dynamic systems. For example, in internal combustion engines, all transport systems – e.g., pipelines – exhibit dead time behavior. This dead time behavior is simulated, for example, in the control unit of an internal combustion engine, in order to obtain measured values ​​using so-called virtual sensors.

[0003] Dead-time elements are used to model dead-time behavior. An incoming data stream at a sampling rate (i.e., write accesses per unit of time) is stored in reserved memory and output after a defined period. Write and read pointers are used to manage memory access. The write pointer is typically incremented by one increment with each call to the dead-time element and reset to zero when the memory is full. To determine the distance between the read and write pointers, the dead time is divided by the sampling rate. If the resulting value is outside the reserved memory area, it is wrapped modulo the memory size. With each call to the dead-time element, a new value is written to the position of the write pointer, and a value is read from the position of the read pointer and output.The maximum representable dead time is limited by the size of the reserved memory section.

[0004] Since the write pointer is incremented by 1 each time and regularly overflows, the reserved memory section is written to cyclically, and no gaps or outdated data are created in the stored data, even if the dead time changes during runtime.

[0005] This allows dead times to be simulated in forward operation, but it does not allow for the modeling of dead times alternating between forward and reverse operation, e.g., of a pipe that is alternately flowed through in two directions.

[0006] Therefore, there is a need for a method to model dead times alternately in both forward and reverse operation.

[0007] From DE 34 29 505 A1, a clock generation device for printing presses is known that enables both positive and negative dead-time compensation. The negative compensation is achieved through the mathematical processing of negative numerical values ​​to effect a shift of clock sequences in the mathematically negative direction.

[0008] From DE 36 33 769 C2, a digital correlator is known in which a read / write memory (RAM) simulating a shift register is used to implement a delay circuit. Data is written by means of a cyclically advanced write pointer and read out by means of a read pointer that has an adjustable distance from the write pointer, in order to effect a unidirectional signal delay. Disclosure of the invention

[0009] Against this background, the present invention proposes a method for modeling dead-time behavior with the features of claim 1, as well as a computing unit and a computer program for carrying it out. Advantages of the invention

[0010] The invention proposes a method for modeling dead-time behavior, which can be implemented in a forward operating mode and a reverse operating mode. In forward operation, memory cells of a memory are selected sequentially in a first sequence using a write pointer to write values ​​into the memory cells, and memory cells from which values ​​are read are selected using a read pointer. Similarly, in reverse operation, memory cells of the memory are selected sequentially in a second sequence using the write pointer to write values ​​into the memory cells, and memory cells from which values ​​are read are selected using the read pointer. The read pointer is determined in both operating modes depending on the write pointer.

[0011] A key aspect of the present invention is that, to switch between operating modes, the write pointer of the target operating mode is set to the last value of the read pointer of the output operating mode. The read pointer of the target operating mode is, in turn, determined based on the write pointer of the target operating mode.

[0012] This allows dead time behavior to be simulated alternately in both forward and reverse operation. Thus, for example, the dead time behavior of a pipe through which flow alternately occurs in two directions can be simulated.

[0013] Implementing the method as a logic circuit or computer program is particularly advantageous because it incurs very low costs, especially if the processing unit is already available for other tasks. Suitable storage media for the computer program include hard drives, flash memory, EEPROMs, CD-ROMs, DVDs, and others. Downloading the program via computer networks (Internet, intranet, etc.) is also possible. An implemented method can also be referred to as a dead-time element (e.g., as a circuit component or module, or as a computer program block).

[0014] According to a preferred embodiment, dead time behavior is simulated in forward operation with a positive dead time value and in reverse operation with a negative dead time value. The dead time value characterizes the distance between the write pointer and the read pointer and is usually specified externally. A switch from forward to reverse operation, or vice versa, is accordingly performed when the dead time value changes sign.

[0015] According to another embodiment, forward operation occurs when the dead time value is zero. This ensures that a switch from forward to reverse operation only occurs when the sign of the dead time value actually changes. If the dead time is zero, i.e., there is no dead time behavior, forward operation is maintained.

[0016] According to another embodiment, the read pointer is determined based on the write pointer by calculating the ratio of the dead time value to a sampling rate. This ensures that the read pointer has a travel distance that corresponds to the dead time of the dead element. The ratio of the dead time value to the sampling rate defines a distance between the read pointer and the write pointer. The sampling rate corresponds to the rate at which the dead time element is called and can be externally specified or, for example, measured.

[0017] According to a further embodiment, when switching from forward to reverse operation or vice versa, the distance between the read pointer and the write pointer is set to a value that corresponded to the value before the change in operating mode. This ensures that interim changes in the dead time cannot cause the output of erroneous values. Preferably, the read pointer is then incrementally set to the value determined by its dependency on the write pointer; for example, the distance can be increased by one increment with each call.

[0018] A computing unit according to the invention, e.g., a control unit of a motor vehicle, is configured, particularly in terms of programming, to carry out a method according to the invention. It can be a control unit with a device for modeling a dead-time element in forward and / or reverse operation, with a memory comprising a plurality of memory cells that can be written with values ​​by means of a write pointer and read out by means of a read pointer. The control unit further comprises a write pointer modification unit for changing the write pointer and a read pointer modification unit for changing the read pointer.

[0019] Further advantages and embodiments of the invention will become apparent from the description and the accompanying drawing.

[0020] It is understood that the features mentioned above and those to be explained below can be used not only in the combinations specified, but also in other combinations or on their own, without leaving the scope of the present invention.

[0021] The invention is schematically illustrated in the drawing using an exemplary embodiment and is described in detail below with reference to the drawing. Brief description of the drawings Fig. Figure 1 shows a schematic representation of the air and exhaust system of an internal combustion engine of a passenger car. Fig. Figure 2 shows a control unit for carrying out a method according to the invention in a schematic representation. Fig. 3 a first procedural stage of the procedure in schematic representation, and Fig. 4 a second procedural step in a schematic representation of the procedure. embodiment(s) of the invention

[0022] In Fig. Figure 1 shows a section of an air and exhaust system 2, e.g., an internal combustion engine of a car.

[0023] The air and exhaust system 2 has a first pipe section 4 and a second pipe section 6, which in the present embodiment extend parallel to each other. The first pipe section 4 and the second pipe section 6 are connected by a connecting pipe 8. In the present embodiment, the connecting pipe 8 can be subjected to gas flow in both forward operation I and reverse operation II. Thus, the connecting pipe 8 exhibits dead-time behavior, which in the present embodiment must be modeled alternately in forward operation I and reverse operation II.

[0024] Dead time behavior is simulated in both forward operation (I) and reverse operation (II), for example, for a lambda model of the control system of an internal combustion engine in a passenger car. The lambda model models the distribution of various substance concentrations, such as oxygen and fuel, within the air and exhaust system (2). The lambda model simulates mixing, storage, and transport of gases, as well as chemical reactions. This model provides information about the current concentration of these substances at different locations within the air and exhaust system (2), and a combustion air ratio (lambda) can be calculated for these locations. This model can be applied to other substances, such as water.

[0025] Transport processes are modeled using one or more dead-time elements 10. For example, the fresh air and exhaust gas systems 2 are connected via a combustion engine, high-pressure EGR (exhaust gas recirculation), and low-pressure EGR. Normally, gas flows in only one direction at any point. However, in a high-pressure EGR line, such as the connecting pipe 8, it can also flow backward. A reversal of direction can occur at any time, even if the gas has not been completely exchanged since the last reversal. To keep the model dynamically accurate and ensure that every concentration change occurs at the correct position at the correct time, the concentration along the gas column, e.g., within the connecting pipe 8, is modeled "in slices." Accurate modeling of dead times, especially reversible dead times, is necessary to maintain the sequence of these slices.

[0026] In Fig. Figure 2 shows a control unit 12 that is designed or configured to model dead times in forward operation I and in reverse operation II. For this purpose, it has a method implemented as a dead-time element 10 according to a preferred embodiment of the invention. The method is implemented in particular as a computer-accessible function.

[0027] In the present embodiment, the dead-time element 10 comprises a memory 14, a write pointer modification unit 16, and a read pointer modification unit 18. The memory 14 and / or the write pointer modification unit 16 and / or the read pointer modification unit 18 can comprise hardware and / or software components.

[0028] Memory 14 can be a reserved section of a memory of the control unit 12. In the present embodiment, memory 14 has a plurality of memory cells S1, S2, ..., Sm, Sn, into each of which a value W1, W2, ..., Wm, Wn can be written and read. In the present embodiment, the memory cells S1, S2, ..., Sm, Sn can be addressed by means of pointers. Thus, in the present embodiment, the values ​​W1, W2, ..., Wm, Wn of the respective memory cells S1, S2, ..., Sm, Sn can be read using a pointer (read pointer LZ). Furthermore, in the present embodiment, the values ​​W1, W2, ..., Wm, Wn can be written into the respective memory cells S1, S2, ..., Sm, Sn using a pointer (write pointer SZ).

[0029] In order to enable the modeling of dead time behavior in both the forward operating mode I and the reverse operating mode II, the dead time element 10 has a write pointer modification unit 16 and a read pointer modification unit 18.

[0030] The writing pointer modification unit 16 is, as will be explained later, designed to change the writing pointer SZ, and the reading pointer modification unit 18 is, as will also be explained later, designed to change the reading pointer LZ.

[0031] It will also be noted that Fig. 3 and Fig. 4. Reference is made to this. The following shows Fig. 3. The modeling of a dead time in forward operation I, while the Fig. Figure 4 shows the modeling of a dead time in reverse operation II. Individual steps or groups of steps can be performed in a sequence that differs from the present embodiment. Typically, several of the described steps run simultaneously or sequentially per function call. Furthermore, steps described in connection with write access and steps described in connection with read access are executed within a single function call. Before the start of regular operation, the memory cells are expediently written with values ​​W that are plausible for the specific application, so that plausible values ​​can be read from the outset. These plausible values ​​can be, for example, stored values ​​from a previous regular operation or default values.

[0032] At the start of the process, a dead time value is read from the dead time element 10. This dead time value is conveniently specified externally based on the physical model to be simulated. From this dead time value and a sampling rate or call rate (see above), the distance between the read pointer and the write pointer can be calculated.

[0033] In a further step, the system checks whether the dead time value is positive or negative and generates a corresponding test result. If the test result indicates that the dead time value is positive, the system operates in forward mode I. If, however, the test result indicates that the dead time value is negative, the system operates in reverse mode II. If the test result indicates that the dead time value is zero, the system operates in forward mode I.

[0034] In a further step, the first memory cell S1 of memory 14 is selected with the write pointer SZ (shown in a dashed line). Then, in a further step, the first value W1 is written into the first memory cell S1. In a further step, the write pointer SZ is incremented by 1 and now points to the second memory cell S2 (shown in a dashed line). Conveniently, the steps described so far, along with a read operation explained in more detail below, are executed simultaneously or sequentially when the function is called.

[0035] On a subsequent function call, the second value W2 is written to the second memory cell S2.

[0036] Thus, in forward operation I, the memory cells S1, S2, ..., Sm, Sn of memory 14 are selected sequentially by function calls in a first sequence R1 using the write pointer SZ, and then the values ​​W1, W2, ..., Wm, Wn are written to the memory cells S1, S2, ..., Sm, Sn in the order of their occurrence. The first sequence R1 can correspond to a sequential arrangement of the memory cells S1, S2, ..., Sm, Sn of memory 14. Alternatively, the first sequence R1 can have any desired order depending on the availability of free memory cells. If the end of memory 14, in this embodiment memory cell Sn, is exceeded by incrementing the write pointer SZ by 1, the write pointer SZ is reset to the first count value (here 1, but 0 is also possible).

[0037] In parallel, with each function call, the read pointer LZ is determined as a function of the write pointer SZ. For this purpose, a quotient of the dead time value and the sampling rate at which the control unit 12 operates is calculated. If the resulting value addresses a memory cell outside of memory 14, it is wrapped using the function modulo the memory size of memory 14. The quotient of the dead time value and the sampling rate determines the distance AB between the read pointer LZ and the write pointer SZ. Thus, the position of the read pointer LZ in memory 14 is determined in a further step by subtracting the calculated distance AB from the position of the write pointer SZ. Fig.When the write pointer addresses memory cell Sn, the read pointer LZ points to memory cell S1. In a further step, memory cell S1 of memory 14 is selected using the determined read pointer LZ. In a further step, the additional value W1 is read from memory cell S1. In a further step, the read pointer LZ is updated. On a subsequent function call, the additional value W2 is read from memory cell S2, to which the read pointer LZ now points.

[0038] Each time the dead-time element 10 is called, a new value is stored and a stored value is read.

[0039] If a check of the dead time value (TZW) reveals, for example, a negative dead time value, a switch from forward operation (I) to reverse operation (II) is performed. For this, the write pointer (SZ) for reverse operation (II) is set to the last value of the read pointer (LZ) in forward operation (I). The read pointer (LZ) for reverse operation (II) is, as explained above, determined based on the write pointer (SZ) for reverse operation (II). If the dead time value does not change during the switch, the read pointer (LZ) for reverse operation (II) will then correspond to the previous write pointer (SZ) for forward operation (I).

[0040] In reverse operation II, the memory cells S1, S2, ..., Sm, Sn of memory 14 are selected one after the other with the write pointer SZ in a second sequence R2, which is the reverse of the first sequence R1.

[0041] However, after switching from, for example, forward operation I to reverse operation II, the dead time value may be greater than before. In this case, the read pointer LZ might address memory cells S1, S2, ..., Sm, Sn of memory 14 that have not yet been written to. Memory cells S1, S2, ..., Sm, Sn of memory 14 would then contain values ​​from the last write cycle, which might be a maximum dead time old, determined by the size of memory 14. Furthermore, the flow in connecting pipe 8 may fluctuate around zero, resulting in frequent changes of operating mode. In this case, the read pointer LZ and the write pointer SZ also oscillate and do not overflow regularly. Therefore, the values ​​can be arbitrarily old.

[0042] To resolve this problem, it is preferably proposed that, even if the dead time value changes during switching, the distance AB is initially limited to its previous value. Accordingly, at the beginning of reverse operation II, the maximum value of the distance AB after the operating mode change is set as a limit value to the value to which the distance AB was set before the operating mode change. The new distance AB is then set to the minimum of the limit value and the actual value, which is the quotient of the dead time value and the sampling rate.

[0043] In the subsequent process, the limit value is then gradually increased to the entire reserved memory size. For example, the limit value can be increased by 1 with each call to the dead-time element 10 until it reaches the memory size and is therefore unlimited.

[0044] In reverse operation II, a value is first written to memory cell S1, to which the write pointer SZ points. In a further step, the write pointer SZ is updated by decrementing it by 1 in this embodiment. In this embodiment, the write pointer then jumps to memory cell Sn (shown in dashed lines). Thus, in reverse operation II, the memory cells S1, S2, ..., Sm, Sn of memory 14 are selected sequentially in the second order R2 using the write pointer SZ and written with further values, which are then read out sequentially.

[0045] Furthermore, if the dead time value increases without a change in operating mode, the read pointer LZ may continue to address the same memory cell S1, S2, ..., Sm, Sn, or even address memory cells S1, S2, ..., Sm, Sn that are in the opposite direction to the direction in which memory cells S1, S2, Sm, Sn are read. To prevent this, changes in the position of the read pointer LZ against the direction of progress can be blocked. This ensures that the output values ​​W1, W2, ... Wm, Wn are always output in their input order.

[0046] The method described so far represents a particularly preferred embodiment of the invention, which can be modified as explained below.

[0047] Contrary to the procedure described above, a read access to memory cells S1, S2, ..., Sm, Sn can, for example, occur before a write access. In this case, if the maximum dead time value is determined by the size of memory 14, the corresponding memory cell S1, S2, ..., Sm, Sn is overwritten immediately after being read. A separate routine, such as a software routine, is provided for the special case of zero dead time.

[0048] Furthermore, contrary to the procedure described above, the reading pointer LZ and / or the writing pointer SZ can be calculated as integers.

[0049] When accessing memory cells S1, S2, ..., Sm, Sn, the index of the read pointer LZ and / or the write pointer SZ must be rounded. In this case, the maximum dead time is no longer directly limited by the size of memory 14. For the special case of non-integer read pointers LZ and / or write pointers SZ, a separate routine, e.g., a software routine, is provided to handle this case and thus prevent data loss.

[0050] Furthermore, deviating from the procedure described above, individual steps in forward operation I may have a different sequence. For example, the procedure in forward operation I may begin with the step "Determining a read pointer LZ depending on the write pointer SZ," or the steps "Selecting a first memory cell S1 of memory 14 with a write pointer SZ" and "Writing a first value W1 into the first memory cell S1" may be performed first, followed by the step "Determining a read pointer LZ depending on the write pointer SZ." Then, for example, the subsequent steps follow.

Claims

[1] Method for modeling dead time behavior in a forward operating mode (I) and in a reverse operating mode (II), wherein in forward operation (I) memory cells (S1, S2, ..., Sm, Sn) of a memory (14) are selected successively in a first sequence (R1) by means of a write pointer (SZ) to write values ​​(W1, W2, Wm, ..., Wn) into the memory cells (S1, S2, ..., Sm, Sn), and are selected by means of a read pointer (LZ) to read the values ​​(W1, W2, Wm, ..., Wn) from the memory cells (S1, S2, ..., Sm, Sn), wherein in reverse operation (II) the memory cells (S1, S2, ..., Sm, Sn) of the memory (14) are selected successively in a second sequence (R2) by means of the write pointer (SZ) to write values ​​(W1, W2, Wm, ..., Wn) into the memory cells (S1, S2, ..., Sm, Sn), and are selected by means of the read pointer (LZ) to read the values ​​(W1, W2, Wm, ..., Wn) from the memory cells (S1, S2, ..., Sm, Sn), where the first sequence (R1) has a different direction of progress than the second sequence (R2), where the reading pointer (LZ) is determined depending on the writing pointer (SZ), where, to switch from an output operating mode to a target operating mode, the write pointer (SZ) of the target operating mode is set to the last value of the read pointer of the output operating mode. [2] Method according to claim 1, wherein a distance (AB) between the read pointer (LZ) and the write pointer (SZ) is determined as a function of a dead time value. [3] Method according to claim 2, which is carried out in forward operation (I) when the dead time value is positive, and which is carried out in reverse operation (II) when the dead time value is negative. [4] Method according to claim 2 or 3, which is carried out in forward operation (I) when the dead time value is zero. [5] Method according to any one of claims 2 to 4, wherein the distance (AB) between the read pointer (LZ) and the write pointer (SZ) is determined as a function of a sampling rate. [6] Method according to claim 5, wherein the distance (AB) between the read pointer (LZ) and the write pointer (SZ) is determined as the quotient of the dead time value and the sampling rate. [7] Method according to any one of claims 2 to 6, wherein the distance (AB) between the read pointer (LZ) and the write pointer (SZ) is limited to a limit value when switching from the initial operating mode to the target operating mode, to which the distance (AB) was set before the change of the operating mode. [8] Method according to claim 7, wherein the limit value is gradually increased to an unlimited value after switching from the initial operating mode to the target operating mode. [9] Method according to one of the preceding claims, wherein when determining the reading pointer (LZ) as a function of the writing pointer (SZ) a change in the position of the reading pointer (LZ) against the direction of progress is prevented. [10] Computing unit configured to perform a method according to any of the preceding claims. [11] Computer program that causes a computing unit to perform a method according to any one of claims 1 to 9 when executed on the computing unit, in particular according to claim 10. [12] Machine-readable storage medium with a computer program stored thereon according to claim 11.

Images