DE102014202877A1 - Method for modeling a deadtime behavior - Google Patents

Abstract

The invention relates to a method for modeling a dead time behavior in a forward mode (I) and in a reverse mode (II), wherein in the forward mode (I) memory cells (S1, S2, ..., Sm, Sn) of a memory (14 ) are successively selected in a first order (R1) by means of a write pointer (SZ) to supply values (W1, W2, Wm, ..., Wn) to the memory cells (S1, S2, ..., Sm, Sn) and read by a read pointer (LZ) to read the values (W1, W2, Wm, ..., Wn) from the memory cells (S1, S2, ..., Sm, Sn), in which Reverse mode (II) the memory cells (S1, S2, ..., Sm, Sn) of the memory (14) by means of the write pointer (SZ) successively in a second order (R2) are selected to values (W1, W2, Wm, ..., Wn) in the memory cells (S1, S2, ..., Sm, Sn), and by means of the read pointer (LZ) are selected to the values (W1, W2, Wm, ..., Wn ) from the memory cells (S1, S2, ..., Sm, Sn), wherein the read pointer (LZ) is determined in response to the write pointer (SZ), wherein for changing from an output mode to a destination mode, the write pointer (SZ) of the target mode to the last value of the read pointer Output mode is set.

Description

The present invention relates to a method for modeling a deadtime behavior, a control device and a computer program.

State of the art

Deadtime behavior is very common in dynamic systems. For example, in internal combustion engines, all transport systems - e.g. Pipelines - a dead time behavior. The deadtime behavior is e.g. in a control unit of an internal combustion engine is simulated to e.g. To obtain measured values by means of so-called virtual sensors.

Deadtime elements are used to model the deadtime behavior. One at a sample rate, i. Write accesses per unit of time, incoming data stream is stored in a reserved memory and output again after a defined period of time. Read and write pointers are used to manage memory access. The write pointer is usually incremented by one increment each time the idle timer is called, and reset to zero upon reaching the end of the memory. To determine the distance of the read pointer to the write pointer, the dead time is divided by the sample rate. If a value outside of the reserved memory area results, it is wrapped with modulo memory size. Each time the idle timer is called, 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 displayable dead time is limited by the size of the reserved memory section.

Since the write pointer is incremented by 1 and regularly overflows, the reserved memory section is cyclically described and there are no gaps in the stored data and no stale data, even if the dead time changes during runtime.

Thus, idle times can be simulated in a forward mode, however, a modeling of dead times is alternately in forward and reverse operation, e.g. a tube that is alternately flowed through in two directions, so not possible.

There is therefore a need for a method of modeling dead times alternately in both forward and reverse modes.

Disclosure of the invention

Against this background, the present invention proposes a method for modeling a deadtime behavior with the features of patent claim 1 and a computing unit and a computer program for its implementation.

Advantages of the invention

The invention proposes a method for modeling a dead-time behavior, which can be carried out in a forward operating mode and in a reverse operating mode. In this case, in the forward operation, memory cells of a memory are successively selected in a first order by means of a write pointer to write values to the memory cells, and memory cells are selected by means of a read pointer from which values are read out. Also, in the reverse operation, memory cells of the memory with the write pointer are successively selected in a second order to write values to the memory cells, and memory cells are selected by means of the read pointer from which values are read out. The read pointer is determined in both modes depending on the write pointer.

An essential aspect of the present invention is that, for switching between the modes, the write pointer of the target mode is set to the last value of the read pointer of the output mode. The read pointer of the target mode is in turn determined in turn depending on the write pointer of the target mode.

This ensures that a deadtime behavior can be simulated alternately both in a forward operation as well as in a reverse operation. Thus, e.g. the deadtime behavior of a tube, which is alternately flowed through in two directions, can be simulated.

An implementation of the method in the form of a logic circuit or a computer program is particularly advantageous, since this causes particularly low costs, in particular if the executing arithmetic unit is still used for further tasks and therefore already exists. Suitable data carriers for providing the computer program are in particular hard disks, flash memories, EEPROMs, CD-ROMs, DVDs and the like. It is also possible to download a program via computer networks (Internet, intranet, etc.). An implemented method may also be referred to as a deadtime member (e.g., a circuit part or block or a computer program block).

According to a preferred embodiment, a deadtime response in forward mode at a positive dead time value and a deadtime response in reverse mode at a negative dead time value is simulated. The deadtime value characterizes the distance between the write pointer and the read pointer and is usually specified externally. Switching from the forward mode to the reverse mode or vice versa is accordingly performed upon a sign change of the dead time value.

In another embodiment, operation is in forward mode when the dead time value is zero. This ensures that a change from the forward to the reverse operation only takes place when the sign of the dead time value actually changes. If the dead time is zero, so there is no deadtime, the forward mode is maintained.

According to a further embodiment, a quotient of the dead time value and a sampling rate is formed for determining the read pointer as a function of the write pointer. This ensures that the read pointer has a running distance that corresponds to the dead time of the dead member. The quotient of the dead time value and the sampling rate defines a distance between the read pointer and the write pointer. The sample rate corresponds to the rate at which the idle timer is called and may be externally preset or e.g. be measured.

According to a further embodiment, in the case of a change from the forward operation to the reverse operation or vice versa, the distance between the read pointer and the write pointer after the change of the operating mode is set to a value which the value had before the change of the operating mode. This ensures that interim changes of the dead time can not cause the output of erroneous values. Preferably, the read pointer is then set stepwise to the value given by the dependency on the write pointer, for example, the distance can be incremented by one increment on each call.

An arithmetic unit according to the invention, e.g. a control device of a motor vehicle is, in particular programmatically, configured to perform a method according to the invention. It can be a control device with a device for modeling a dead-time element in a forward mode and / or a reverse mode, with a memory having a plurality of memory cells, which can be read by means of a write pointer with values and read by means of a read pointer. The controller further includes a write pointer modification unit for changing the write pointer and a read pointer modification unit for changing the read pointer.

Further advantages and embodiments of the invention will become apparent from the description and the accompanying drawings.

It is understood that the features mentioned above and those yet to be explained below can be used not only in the particular combination indicated, but also in other combinations or in isolation, without departing from the scope of the present invention.

The invention is illustrated schematically with reference to an embodiment in the drawing and will be described in detail below with reference to the drawing.

Brief description of the drawings

1 shows an air and exhaust system of an internal combustion engine of a car in a schematic representation,

2 shows a control device for carrying out a method according to the invention in a schematic representation,

3 a first method section of the method in a schematic representation, and

4 a second process section in a schematic representation of the method.

Embodiment (s) of the invention

In 1 is a section of an air and exhaust system 2 shown, for example, an internal combustion engine of a car.

The air and exhaust system 2 has a first pipe section 4 and a second pipe section 6 on, which extend parallel to each other in the present embodiment. The first pipe section 4 and the second pipe section 6 connects a connecting pipe 8th , In the present embodiment, the connecting pipe 8th be traversed in both a forward operation I and in a reverse operation II of gases. Thus shows the connecting pipe 8th a deadtime behavior, which must be modeled alternately in a forward operation I and in a reverse operation II in the present embodiment.

The dead time behavior is simulated both in forward operation I and in reverse operation II, for example for a lambda model of a regulation of an internal combustion engine of a passenger car. The lambda model models the distribution different substance concentrations, such as oxygen and fuel within the air and exhaust system 2 , The lambda model models the mixture, storage, transport of gas and chemical reactions. This model provides information about the current concentration of these substances at different positions of the air and exhaust systems 2 are available, and a combustion air ratio (lambda) for the positions can be calculated. This model can be applied to other substances, such as water.

Transport operations are doing with one or more deadtime members 10 modeled. For example, the fresh and exhaust system 2 via an internal combustion engine, high pressure EGR (exhaust gas recirculation) and low pressure EGR medium leading connected. Normally, gas always flows in only one direction at any point. In a high-pressure EGR line, such as the connecting pipe 8th but it can also flow backwards. A reversal of direction can occur at any time, even if the gas has not been completely replaced since the last reversal of direction. In order to keep the model dynamically accurate and to ensure that any change in concentration is in the correct position at the right time, the concentration will be along the gas column, eg inside the connection tube 8th , "sliced" model. To maintain the order of these slices, a correct modeling of dead times, especially of reversible dead times, is required.

In 2 is a control unit 12 illustrated that is configured for modeling dead times in the forward mode I and in the reverse mode II. It has as a deadtime member 10 implemented method according to a preferred embodiment of the invention. The method is in particular computer-implemented as a callable function.

In the present embodiment, the deadtime element 10 a memory 14 , a write pointer modification unit 16 and a read pointer modification unit 18 on. The memory 14 and / or the write pointer modification unit 16 and / or the read pointer modification unit 18 may include hardware and / or software components.

The memory 14 may be a reserved portion of a memory of the controller 12 be. In the present embodiment, the memory 14 a plurality of memory cells S1, S2, ..., Sm, Sn, in each of which a value W1, W2, ..., Wm, Wn can be written and read out therefrom. In the present exemplary embodiment, the memory cells S1, S2,..., Sm, Sn can be addressed by means of pointers. Thus, in the present exemplary embodiment, the values W1, W2,..., Wm, Wn of the respective memory cells S1, S2,..., Sm, Sn can be read out by means of a pointer read pointer LZ. Furthermore, in the present exemplary embodiment, the values W1, W2,..., Wm, Wn can be written into the respective memory cells S1, S2,..., Sm, Sn by means of a pointer write pointer SZ.

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

The write pointer modification unit 16 is, as will be explained later, for changing the write pointer SZ, and the read pointer modification unit 18 is, as will also be taught later, designed to change the read pointer LZ.

It will be added to the 3 and 4 Referenced. It shows the 3 the modeling of a dead time in the forward mode I, while the 4 the modeling of a dead time in the reverse mode II shows. In this case, individual steps or even groups of steps can be carried out in a different order from the present embodiment. Also, typically several of the described steps occur simultaneously or sequentially per call of the function. Furthermore, steps described in connection with the write access and steps described in connection with the read access take place in a function call. Before the start of the control operation, the memory cells are expediently described with values W that are plausible for the specific application, so that plausible values can be read from the beginning. The plausible values can be, for example, stored values from a previous control mode or default values.

At the beginning of the process, a dead time value of the deadtime member 10 read. The dead time value is expediently specified externally on the basis of the physical model to be simulated. From the dead time value and a sampling rate or call rate (see above), the distance between read pointer and write pointer can be calculated.

In a further step, it is checked 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, operation is in forward mode I. On the other hand, if the test result indicates that the dead time value is negative, the operation is in reverse mode II. If the test result indicates that the dead time value is zero, a Operation in forward operation I.

In a further step, the first memory cell S1 of the memory 14 selected with the write pointer SZ (shown in dashed line). Then, in a further step, the first value W1 is written in the first memory cell S1. In a further step, the write pointer SZ is increased by 1, and now points to the second memory cell S2 (shown in dashed lines). Expediently, the steps explained so far, together with a reading process explained in greater detail below, run simultaneously or successively when the function is called.

In a further function call, the second value W2 is written in the second memory cell S2.

Thus, in the forward mode I, the memory cells S1, S2, ..., Sm, Sn of the memory become 14 with the write pointer SZ successively selected by function calls in a first order R1 and then written the values W1, W2, ..., Wm, Wn in the order of their occurrence in the memory cells S1, S2, ..., Sm, Sn. The first order R1 can be a row-shaped arrangement of the memory cells S1, S2,..., Sm, Sn of the memory 14 correspond. Deviating from this, the first order R1 can have an arbitrary course as a function of the availability of free memory cells. If by increasing the write pointer SZ by 1 the end of the memory 14 , In the present embodiment, the memory cell Sn, is exceeded, the write pointer SZ is again set to the first count (here 1, as well as 0 is possible).

In parallel, the read pointer LZ is determined as a function of the write pointer SZ during each function call. For this purpose, a quotient of the dead time value and the sampling rate is formed, with which the control unit 12 is working. If a value results, the memory cell is out of memory 14 addressed, he is using the function modulo memory size of the memory 14 wrapped. In this case, 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 the memory becomes 14 determined in a further step by subtracting the determined distance AB from the position of the write pointer SZ. When in 2 the write pointer addresses the memory cell Sn, the read pointer LZ points to the memory cell S1. In a further step, the memory cell S1 of the memory is now used with the determined read pointer LZ 14 selected. In a further step, the further value W1 is read out of the memory cell S1. In a further step, the read pointer LZ is updated. In another function call, the further value W2 is read out of the memory cell S2, to which the read pointer LZ now points.

Every time the deadtime element is called 10 Thus, a new value is stored and read out a stored value.

Now if a check of the dead time value TZW shows that e.g. Now there is a negative dead time value, a change from the forward operation I in the reverse operation II is performed. For this purpose, the write pointer SZ for the reverse operation II is set to the last value of the read pointer LZ in forward operation I. The read pointer LZ for the reverse operation II is basically, as already explained above, determined in dependence on the write pointer SZ for the reverse operation II. If the amount of the dead time value does not change during the changeover, the read pointer LZ for the reverse operation II then corresponds to the previous write pointer SZ for the forward operation I.

In reverse mode II, the memory cells S1, S2, ..., Sm, Sn of the memory 14 with the write pointer SZ successively selected in a second order R2, which is reverse to the first order R1.

However, after a change from, for example, the forward operation I to the reverse operation II, it may happen that the amount of the dead time value is larger than before. Then the read pointer LZ would possibly memory cells S1, S2, ..., Sm, Sn of the memory 14 address that have not been described yet. The memory cells S1, S2, ..., Sm, Sn of the memory 14 then contain values from the last write cycle that are, for example, a maximum dead time old, the size of the memory 14 sets. Further, the case may occur that the flow in the connecting pipe 8th fluctuates around zero, and therefore often a change of the operating mode takes place. Then also the read pointer LZ and the write pointer SZ swing and do not run over regularly. Then the values can be any age.

To remedy this problem, it is preferably provided to initially limit the distance AB to the previous value even if the amount of the dead time value changes during the changeover. Thus, at the beginning of the reverse operation II, the maximum value of the distance AB after the change of the operation mode is set as the limit value to a value to which the distance AB was set before the change of the operation mode. The new distance AB is then set to the minimum of the limit value and the actual value, which results as the quotient of the dead time value and the sampling rate.

In the further procedure, the limit value is then incrementally increased to the total reserved memory size. The limit value may be, for example, every time the deadtime element is called 10 increased by 1 until it reaches the memory size and is thus unlimited.

In reverse mode II, a value is first written into the memory cell S1, to which the write pointer SZ points. In a further step, the write pointer SZ is updated by being decremented by 1 in the present exemplary embodiment. In the present embodiment, the write pointer then jumps to the memory cell Sn (shown in dashed line). Thus, in the reverse mode II, the memory cells S1, S2, ..., Sm, Sn of the memory become 14 with the write pointer SZ successively selected in the second order R2 and described with further values, which are then read out sequentially.

Furthermore, with an increase in the dead time value without a mode change, it may occur that the read pointer LZ continues to address the same memory cell S1, S2,..., Sm, Sn or even memory cells S1, S2,..., Sm, Sn addressed, which are opposite to the direction of progress, with which the 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 prevented. Thus it can be achieved that the output values W1, W2,... Wm, Wn are always output in their order of input.

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

Notwithstanding the procedure described above, for example, a read access to the memory cells S1, S2, ..., Sm, Sn before a write access. Then, at a maximum dead time value, that is the size of the memory 14 determines, the corresponding memory cell S1, S2, ..., Sm, Sn overwritten directly after reading again. For the special case of zero dead time, a separate routine, eg a software routine, is provided, which deals with this case.

Furthermore, notwithstanding the procedure described above, for example, the read pointer LZ and / or the write pointer SZ can not be calculated as an integer. An index of the read pointer LZ and / or the write pointer SZ is then to round when accessing the memory cells S1, S2, ..., Sm, Sn. Then here the maximum dead time value is no longer directly dependent on the size of the memory 14 limited. For the special case non-integer calculated read pointer LZ and / or write pointer SZ a separate routine, such as a software routine, is provided, which handles this case and thus prevents data loss.

Furthermore, different from the method sequence described above, for example, individual steps in forward mode I may have a different order. For example, in forward operation I, the method may begin with the step "determining a read pointer LZ as a function of the write pointer SZ", or, for example, only the steps "selecting a first memory cell S1 of a memory 14 with a write pointer SZ "and" writing a first value W1 into the first memory cell S1, followed by the step "determining a read pointer LZ in response to the write pointer SZ". Then, for example, follow the further steps.

Claims (12)

Method for modeling a dead time behavior in a forward mode (I) and in a reverse mode (II), wherein in the forward mode (I) memory cells (S1, S2, ..., Sm, Sn) of a memory ( 14 ) are successively selected in a first order (R1) by means of a write pointer (SZ) to supply values (W1, W2, Wm, ..., Wn) to the memory cells (S1, S2, ..., Sm, Sn) and read by a read pointer (LZ) to read the values (W1, W2, Wm, ..., Wn) from the memory cells (S1, S2, ..., Sm, Sn), in which Reverse mode (II) the memory cells (S1, S2, ..., Sm, Sn) of the memory ( 14 ) are successively selected in a second order (R2) by means of the write pointer (SZ) to supply values (W1, W2, Wm, ..., Wn) to the memory cells (S1, S2, ..., Sm, Sn) and read by the read pointer (LZ) to read the values (W1, W2, Wm, ..., Wn) from the memory cells (S1, S2, ..., Sm, Sn), the first Order (R1) has a different direction of progress than the second order (R2), wherein the read pointer (LZ) is determined in response to the write pointer (SZ), wherein to change from an output mode to a destination mode, the write pointer (SZ) of the target mode on the last value of the reading pointer of the output mode is set. The method of claim 1, wherein a distance (AB) between the read pointer (LZ) and the write pointer (SZ) is determined in dependence on a dead time value. A method according to claim 2, which is performed in the forward mode (I) when the dead time value is positive, and which is performed in the reverse mode (II) when the dead time value is negative. A method according to claim 2 or 3, performed in the forward mode (I) when the dead time value is zero. Method according to one of claims 2 to 4, wherein the distance (AB) between the read pointer (LZ) and the write pointer (SZ) is determined in dependence on a sampling rate. The method of claim 5, wherein the distance (AB) between the read pointer (LZ) and the write pointer (SZ) is determined as a quotient of the dead time value and the sampling rate. Method according to one of claims 2 to 6, wherein the distance (AB) between the read pointer (LZ) and the write pointer (SZ) when changing from the output mode to the target mode is limited to a limiting value to which the distance (AB) before the Change of operating mode was set. The method of claim 7, wherein the limit value is incrementally increased to an infinite value after switching from the output mode to the destination mode. Method according to one of the preceding claims, wherein in the determination of the read pointer (LZ) in dependence on the write pointer (SZ), a change of the position of the read pointer (LZ) against the direction of progress is prevented. Arithmetic unit which is adapted to carry out a method according to one of the preceding claims. Computer program that causes a computing unit to perform a method according to one of claims 1 to 9 when it is executed on the computing unit, in particular according to claim 10. Machine-readable storage medium with a computer program stored thereon according to claim 11.

Images