INTERNAL VEHICLE CONTROL DEVICE

Abstract

An in-vehicle control device is provided that can set a data age for input data of a time-synchronous application, reference itself to the latest value within the time-synchronous application, and reduce latency. An in-vehicle control device 1 comprises a plurality of computing devices 13 and control units 12 and 52 that control the plurality of computing devices 13. The control units 12 and 52 control the plurality of computing devices 13 such that the plurality of computing devices 13 execute a second time-synchronous application, which has a dependency relationship with a first time-synchronous application, within a cycle in which the first time-synchronous application is executed.

Description

Technical field

[0001] The present invention relates to an in-vehicle control device and an improvement in software development efficiency in a controller with multiple mounted cores for an automobile. State of the art

[0002] An automotive control system comprises a multitude of electronic control units (ECUs). An ECU must perform sensor input processing, target value calculation processing, control processing, and actuator control processing to meet a strict time constraint (deadline). For high functionality, a multi-core compatible system-on-chip (SoC) is employed, housing a variety of high-performance CPUs. Integration of ECUs into high-affinity functional groups, such as those found in autonomous driving systems, powertrains, and chassis, and integration of ECUs into tightly packed groups within a vehicle, such as front-mounted ECU clusters, are being pursued to reduce costs and space requirements. With further improvements in safety and comfort, each function has become highly functional, resulting in extensive and complex software.

[0003] In an automotive control system, the addition of a function or a load redistribution of an existing function (verification of an execution kernel) occurs during development. These changes must be implemented to meet deadlines; however, there is a possibility that the impact on the software using a calculation result will propagate not only due to real-time performance guarantees of the target software, but also due to a change in the execution time of the target software. Thus, the problem arises that the work hours required for the design increase due to an impact analysis.

[0004] This event is a problem that occurs when software is updated after it has been sold, and a solution is desired.

[0005] One solution proposed was the Logical Execution Time (LET) paradigm, a time-synchronized design scheme. LET is a design methodology where an input time for a periodically executed application is set at the beginning of a period (LET interval), and an output time is set at the end of the period (LET interval), allowing the application's arithmetic processing to finish between an input and an output. For example, any application running in a kernel, even if a new application is executed in that specific kernel as a function addition, can check whether the arithmetic processing finishes by the output time. It is unnecessary to consider propagation of influence to other applications, and the man-hours required for design can be reduced.

[0006] Accordingly, considering the extensibility that a function addition can support, it is desirable to set the granularity of an application configured by the ECU to a granularity (units of groups) subject to the premise of load distribution.

[0007] However, if an application is defined in units of functions, LET requires a time of one cycle in each application from an input to an output, and there is the problem that latency deteriorates.

[0008] In the technique described in PTL 1, when the time-synchronous design scheme is applied to applications with different execution cycles, a multitude of buffers are provided for exchanging data between the applications (multibuffers), and the input and output buffers are defined as distinct entities, thus eliminating access latency by making exclusive control in the manner of a semaphore unnecessary, which can improve CPU utilization efficiency. List of patent literature

[0009] PTL 1: JP 2022-14679 A Summary of the invention: Technical problem

[0010] However, the technique described in PTL 1 cannot solve the deterioration in latency, which is a problem arising in the present invention, since the form of an input at the beginning of the cycle and an output at the end of the cycle does not change.

[0011] The present invention was made to solve the above-mentioned problems, and one objective of the present invention is to provide an in-vehicle control device that can set a data age for input data of a time-synchronous application, can refer to itself in a time-synchronous application to a latest value, and can reduce latency. Solution to the problem

[0012] To achieve the above objective, the present invention is designed as follows.

[0013] An in-vehicle control device according to one aspect of the present invention comprises: a plurality of computing devices and a control unit designed to control the plurality of computing devices. The control unit controls the plurality of computing devices such that they execute a second time-synchronous application, which has a dependency relationship with a first time-synchronous application, within a cycle in which the first time-synchronous application is executed. Advantageous effects of the invention

[0014] It is possible to provide an in-vehicle control device that can set a data age for input data of a time-synchronous application, can refer to a latest value in the time-synchronous application itself, and can reduce latency.

[0015] A vehicle control device according to the present invention makes it possible to easily implement a functional addition or load distribution of existing applications for a system that requires short latency and to improve development efficiency. Brief description of the drawings

[0016] They show: Fig. 1 a diagram showing a configuration of an in-vehicle control device according to Example 1, Fig. 2 a diagram showing a functional block of an in-vehicle control device according to Example 1, Fig. 3. A diagram showing an example of data flow information according to Example 1. Fig. 4. A diagram showing an example of software execution information according to Example 1. Fig. 5 a diagram showing an example of a data age expectation value and data age correction information according to Example 1, Fig. 6A a diagram showing a time series execution sequence when the present invention is not applied, Fig. 6B a diagram showing a time series execution sequence when the present invention is not applied, Fig. 7 a diagram showing a data age-compatible data access flow in which the multi-buffer is used according to Example 1, Fig. 8 a diagram showing a time series execution sequence according to Example 1, Fig. 9 a diagram showing an example of a data age estimate according to Example 1, Fig. 10 a diagram showing an example of a multi-buffer according to Example 1, Fig. 11 a diagram showing an example of a local buffer according to Example 1, Fig. 12 a diagram showing an example of a buffer index according to Example 1, Fig. 13 a diagram showing an example of a cycle counter according to Example 1, Fig. 14 a diagram showing a processing flow of a data age calculation unit according to Example 1, Fig. 15 a processing flow of a data age synchronization correction unit according to Example 1, Fig. 16 a processing flow of an application launch management unit according to Example 1, Fig. 17 a diagram showing a processing flow of a data-age-compatible buffer management unit according to Example 1, Fig. 18 a diagram showing a processing flow of the data-age-compatible buffer reference unit according to Example 1, Fig. 19 a diagram showing a processing flow of a data-age-compatible buffer update unit according to Example 1, Fig. 20 a diagram showing a processing flow of an application unit according to Example 1, Fig. 21 a diagram showing a configuration of an in-vehicle control device according to Example 2, Fig. 22 a block diagram showing a functional configuration of an in-vehicle control device according to Example 2, Fig. 23 a diagram showing a processing flow of a data age synchronization correction unit according to Example 2, Fig. 24 a diagram showing an example of software execution information according to Example 2, Fig. 25 a diagram showing an example of a data age estimate according to Example 2, Fig. 26 a diagram showing an example of a data age expectation value and data age correction information according to Example 2, Fig. 27 a diagram showing an example of software execution correction information according to Example 2, Fig. 28 a diagram showing a data age-compatible data access flow in which the multi-buffer is used according to Example 2, Fig. 29 a diagram showing a configuration of an in-vehicle control device according to Example 3, Fig. 30 a diagram showing a functional block of an in-vehicle control device 3 according to Example 3, Fig. 31 a diagram showing a processing flow of a data-age-compatible buffer reference unit according to Example 3, Fig. 32 a diagram showing a processing flow of a data-age-compatible buffer update unit according to Example 3, Fig. 33 a diagram showing a processing flow of an application unit according to Example 3, Fig. 34 a diagram showing a configuration of an in-vehicle control device according to Example 4, Fig. 35 a diagram showing a functional block of the vehicle's internal control device according to Example 4, Fig. 36 a diagram showing a configuration of an in-vehicle control device according to Example 5, and Fig. 37 a diagram showing a functional block of an in-vehicle control device according to Example 5. Description of embodiments

[0017] An in-vehicle control device according to the present invention estimates the data age of an application group and corrects it so that no expected value or jitter occurs. The time-synchronized application can refer to input data according to the defined data age.

[0018] Embodiments of the present invention are described below with reference to the drawings. Examples<Beispiel 1>

[0019] Fig. Figure 1 is a diagram showing a configuration of a system according to Example 1 of the present invention.

[0020] In Fig. The invention comprises a vehicle-integrated control device 1, an ECU 12 (control unit), and a development environment 11. A plurality of CPUs (computers) 13 and a memory 14, which stores programs, sensor input values, calculation results, and the like, are mounted on the ECU 12, which is connected to a network 15, a sensor 16, and an actuator 17 for communicating with other ECUs. It is also conceivable that a CPU 13 has a plurality of cores. Accordingly, the present invention relates to the ECU 12, which has the plurality of CPUs 13 or a plurality of cores.

[0021] Fig. Figure 2 is a diagram showing a functional block of the vehicle's internal control device according to Example 1. Fig. In the development environment 11, a data age calculation unit 113 outputs a data age estimate 114 based on data flow information 111 and software execution information 112. A data age synchronization correction unit 115 takes the data age estimate 114 as input and outputs data age correction information 116, in which any data age jitter is corrected.

[0022] In the ECU 12, an application start management unit 121 is executed periodically to periodically update a cycle counter 122. Then, an application 125 is started based on the software execution information 112. A data-age-compatible buffer management unit 123 updates a buffer index 124, which specifies a target of a multi-buffer 128, based on the cycle counter 122. The application 125, through the data-age-compatible buffer reference unit 126, references a value from the multi-buffer 128 specified by the buffer index 124, copies the value to the local buffer 127, and performs arithmetic processing. Based on the calculation result, the value of the multi-buffer 128 specified by the buffer index 124 is updated by the data-age-compatible buffer update unit 129.

[0023] The data-age-compatible buffer reference unit 126 determines a reference target of the multi-buffer 128 in accordance with the data age based on the buffer index 124.

[0024] Fig. Figure 3 shows an example of data flow information according to Example 1. Fig. Figure 3 shows the data flow information 111 A1 to A11 from eleven applications 125. A name is assigned to each data flow between applications. For example, data output by A1 and input by A6 is D16. In Example 1, an application for automated driving is specified as the target, but the applications to which the present invention is applied are not limited to this. The present invention is also applicable when a powertrain control application, a chassis control application, and a plurality of applications are integrated.

[0025] Fig. Figure 4 shows an example of the software execution information according to Example 1. The software execution information 112 includes an application name, corresponding application content, an application execution cycle, an application execution priority, application startup information, and a core ID for executing the application. The startup information is described as information that specifies either a "time" at which the application starts at the beginning of the cycle or an "event" to be executed after a specific application terminates. There is also an event that is executed when both of the two applications terminate, as in A5. The actual state of the application execution priority is assumed to be the priority of a task, thread, or process.According to the present invention, it is assumed that the processing is completed within one cycle in which each application is performed.

[0026] Fig. Figure 5 shows an example of a data age expectancy value and the data age correction information 116 according to Example 1. The data age expectancy value and the data age correction information 116 have a data name, corresponding contents and information regarding the data age to be obtained.

[0027] The Fig. 6A and Fig. 6B are time series execution sequences when the present invention is not applied. Fig. 6A displays 0 ms to 150 ms, and Fig. 6B shows 150 ms to 400 ms.

[0028] When the data flow information 111 and the software execution information 112 are executed by the time-synchronized application, a time equal to one cycle is required in each application, resulting in significant latency. For example, a critical path that causes high latency is a data flow from A2 or A3, A5, A6, A7, A8, A9, and A10 or A11, and it takes approximately 400 ms from the start to the end of the data flow information 111. Because A6 and A7 have different cycles, there is also an event where data cannot be transferred in the next cycle (150 ms) from A6 and cannot be transferred until the next cycle (200 ms) from A7. As in Fig. 6A and Fig. As shown in Figure 6B, it can be understood that the time (latency) required from an input to an output of all applications is approximately 400 ms.

[0029] Fig. 7 is a data age-compatible data access flow that uses the multi-buffer as described in Example 1. The following description focuses on a data flow between A6, A7, A9, and A10 of application 125. According to the software execution information 112, A6 and A7 run on CPU 4, and A9 and A10 run on CPU 6. Applications A6 and A7 have a dependency relationship with each other.

[0030] According to the present invention, in order to enable the acquisition of data corresponding to the data age, a multi-buffer scheme is used to manage data for each data age in shared data exchanged with application 125. A method for defining the number of multi-buffers is described below using formula (1).

[0031] According to data flow information 111, data D16, which is intended to be an output of A1, and data D56, which is intended to be an output of A5, are inputs of A6. In accordance with the Fig. The data age expected value shown in Figure 5 is 1. A data age of 0 indicates a result calculated in the same cycle based on an application on a receiving side of target data, and a data age of 1 indicates a result calculated during a previous cycle. That is, a computation result of the application running within a LET interval of the application on the receiving side is a data age of 0. A data age of N is a result calculated during N previous cycles.

[0032] As described above, in the present invention, data age is expressed through a relative relationship with the application on the receiving side of the target data. That is, the data age is expressed by relative data age information, in which a difference in execution time between applications where a data reference relationship occurs is expressed as a relative relationship. Accordingly, a general-purpose implementation is enabled.

[0033] Therefore, A6 references D16 and D56, which are stored in the buffer where the data age of the shared data (50 ms) is 1, and stores the data in local data buffer 127. A calculation is then performed using this data. As a result of the calculation, D67 and D69 are stored in a buffer where the data age of the shared data (50 ms) is 0.

[0034] A7 refers to data D67, which is stored in the buffer with a data age of 0 in the shared data (50 ms); A9 refers to data D69, which is stored in the buffer with a data age of 1 in the shared data (50 ms); and A10 refers to data D910, which is stored in the buffer with a data age of 0 in the shared data (50 ms). As described above, the latency, even in time-synchronized applications, can be reduced by making it possible to reference data from the buffer with a data age of 0.

[0035] It is necessary to change the data age of data in cycle units in each application. This is done by the data-age-compatible buffer management unit 123 (exchange).

[0036] The following formula (1) is a calculation formula for determining the number of multi-buffers (a multitude of buffers provided for data). NBuffercounter=MaxDataAgereceiver+1

[0037] As shown in formula (1), the number of multibuffers (NBuffercounter) is a value (MaxDataAgereceiver+1) obtained by adding 1 to the highest number in the request data age for the target data. For example, if the request data age is 2, the number of multibuffers is 3.

[0038] A first time-synchronous application is output to the multi-buffer 128, and a second time-synchronous application refers to a buffer corresponding to the data age.

[0039] Fig. Figure 8 shows a time-series execution sequence according to Example 1. Fig. 8 indicates a dashed arrow between applications for data communication with a data age of 0, and a solid arrow indicates data communication with a data age of 1 or more. As in Fig. As shown in Figure 8, the time (latency) required from input to output of all applications is approximately 200 ms. It can be understood that this is significantly lower compared to a case where the present invention, described in Figure 8, is used. Fig. 6A and Fig. As shown in 6B, it is not applied and can be greatly shortened.

[0040] Fig. Figure 9 shows an example of the data age estimate of 114 according to Example 1. Fig. 9 the data age estimate 114 has a data name and corresponding contents as well as information regarding the data age in which a result of the data age calculation unit 113 is stored.

[0041] Fig. Figure 10 shows an example of the multi-buffer 128 according to Example 1. In Fig. 10. The multi-buffer 128 has a data name, a buffer index, a data age, and a buffer value.

[0042] Fig. Figure 11 shows an example of the local buffer 127 according to Example 1. Fig. 11. The local buffer 127 has a data name and a buffer value.

[0043] Fig. Figure 12 shows an example of the buffer index 124 according to Example 1. Fig. In case 12, buffer index 124 has a data name and an index.

[0044] Fig. Figure 13 shows an example of the cycle counter 122 according to Example 1. Fig. The cycle counter 13 is configured with information from cycle counter 122. Cycle counter 122 identifies a time elapsed.

[0045] The following describes details of an operational process according to Example 1.

[0046] Fig. 14 is a processing flow of the Data Age Calculation Unit 113. The Data Age Calculation Unit 113 calculates a data age for at least one or more data units exchanged between applications, based on data flow information and software execution information, and outputs the data age as the Data Age Estimate 114. Each step is described below. (FIG. 14: Step 1131)

[0047] The data age calculation unit 113 reads the data flow information 111 and the software execution information 112. (FIG. 14: Step 1132)

[0048] The data age calculation unit 113 determines whether the data age has been calculated for each data flow. If there is an uncalculated data flow (in the case of true), the process proceeds to step 1133 to start the data age calculation for a target data flow. If there are no uncalculated data flows (in the case of false), the processing flow ends. (FIG. 14: Step 1133)

[0049] The data age calculation unit 113 uses the software execution information 112 to determine whether a sending application and a receiving application of the target data flow are running in the same core. If so, the process proceeds to step 1134. If not, the process proceeds to step 113B. (FIG. 14: Step 1134)

[0050] The data age calculation unit 113 uses the software execution information 112 to determine whether the receiving application of the target data flow is executed with an event trigger. If so, the process proceeds to step 1135. If not, the process proceeds to step 1136. (FIG. 14: Step 1135)

[0051] The data age calculation unit 113 sets the data age value of the target data flow to 0. (FIG. 14: Step 1136)

[0052] The data age calculation unit 113 uses the software execution information 112 to determine whether the sending application of the destination data flow has a higher priority than the receiving application. If so, the process proceeds to step 1137. If not, the process proceeds to step 1138. (FIG. 14: Step 1137)

[0053] The data age calculation unit 113 sets the data age value of the target data flow to 0. (FIG. 14: Step 1138)

[0054] The data age calculation unit 113 uses the software execution information 112 to determine whether the priorities of the sending and receiving applications of the target data flow are the same. If so, the process proceeds to step 1139. If not, the process proceeds to step 113A. (FIG. 14: Step 1139)

[0055] The data age calculation unit 113 sets a data age value of the target data flow to 0 or 1. NM of a data age value means that jitter occurs such that a minimum value is N and a maximum value is M. For example, a data age of 0-1 means that the data age can be either 0 or 1. (FIG. 14: Step 113A)

[0056] The data age calculation unit 113 sets the data age value of the target data flow to 1. (FIG. 14: Step 113B)

[0057] The data age calculation unit 113 uses the software execution information 112 to determine whether the receiving application of the target data flow is executed with an event trigger. If so, the process proceeds to step 113C. If not, the process proceeds to step 113D. (FIG. 14: Step 113C)

[0058] The data age calculation unit 113 sets the data age value of the target data flow to 0. (FIG. 14: Step 113D)

[0059] The data age calculation unit 113 uses the software execution information 112 to determine if no other application is running in the kernel where the receiving application of the target data flow is running. If so, the process proceeds to step 113E. If not, the process proceeds to step 113F. (FIG. 14: Step 113E)

[0060] The data age calculation unit 113 sets the data age value of the target data flow to 1. (FIG. 14: Step 113F)

[0061] The data age calculation unit 113 uses the software execution information 112 to determine whether the receiving application has the highest priority in the core where the receiving application of the target data flow is running. If so, the process proceeds to step 113G. If not, the process proceeds to step 113H. (FIG. 14: Step 113G)

[0062] The data age calculation unit 113 sets the data age value of the target data flow to 1. (FIG. 14: Step 113H)

[0063] The data age calculation unit 113 uses the software execution information 112 to determine whether all other applications running in the kernel where the receiving application of the target data flow is running are ready to start in an event from the receiving application. If so, the process proceeds to step 113I. If not, the process proceeds to step 113J. (FIG. 14: Step 113I)

[0064] The data age calculation unit 113 sets the data age value of the target data flow to 1. (FIG. 14: Step 113J)

[0065] The data age calculation unit 113 sets the data age value of the target data flow to 0 or 1.

[0066] Fig. 15 is a processing flow of the data age synchronization correction unit 115. If jitter occurs in the data age of the data age estimate 114, the data age synchronization correction unit 115 corrects the data age so that the data age assumes a constant value and is either high or low. Each step is described below. (FIG. 15: Step 1151)

[0067] The data age synchronization correction unit 115 reads the data age estimate 114. (FIG. 15: Step 1152)

[0068] The data age synchronization correction unit 115 uses the data age estimate 114 to determine whether there is a data flow with data age jitter. If so, the process proceeds to step 1153. If not, the process proceeds to step 1154. (FIG. 15: Step 1153)

[0069] The data age synchronization correction unit 115 fixes the data age of a data flow in which jitter occurs. This fix can be consistent with a preset fix. In Example 1, the data age is set to 1. (FIG. 15: Step 1154)

[0070] The data age synchronization correction unit 115 outputs information regarding the data age corrected in this process based on the data age estimate 114 as the data age correction information 116.

[0071] Fig. 16 is a processing flow of the application launch management unit 121. Each step is described below. (FIG. 16: Step 1211)

[0072] The application launch management unit 121 is executed periodically to increment the cycle counter 122 (adds 1). (FIG. 16: Step 1212)

[0073] The application launch management unit 121 reads the software execution information 112. (FIG. 16: Step 1213)

[0074] The application launch management unit 121 uses the software execution information 112 to determine if there is an application to be launched in the current cycle. For example, it determines if there is an application to be launched at a multiple of the smallest cycle, which serves as a reference among all applications. Since, for example, the smallest cycle in Example 1 is 50 ms, the application launch management unit 121 is launched at a cycle time of 50 ms and adds 1 to the cycle counter 122 at 50 ms intervals. If the application's cycle time is 100 ms, the application will be launched at a time when the cycle counter 122 is a multiple of 2. If the determination result is true, the process continues to step 1214. If the determination result is false, this processing flow ends. (FIG. 16: Step 1214)

[0075] The application launch management unit 121 starts the target application 125.

[0076] Fig. 17 is a processing flow of the data age-compatible buffer management unit 123. Each step is described below. (FIG. 17: Step 1231)

[0077] The data-age-compatible buffer management unit 123 determines whether the execution is a first execution. If so, the process proceeds to step 1232. If not, the process proceeds to step 1233. (FIG. 17: Step 1232)

[0078] The data age-compatible buffer management unit 123 sets the multi-buffer 128 based on the data age correction information 116 and the formula (1) described above. (FIG. 17: Step 1233)

[0079] The data-age-compatible buffer management unit 123 determines, based on the cycle counter 122, whether the application 125 to be executed in the current cycle is located there. If the determination result is true, the process continues to step 1234. If the determination result is false, the processing flow ends. (FIG. 17: Step 1234)

[0080] The data-age-compatible buffer management unit 123 switches the data age of the multi-buffer 128 by changing a buffer index to control an access target according to the age of data output by the application to be started, corresponding to the cycle counter 122 for the multi-buffer 128. For example, in the multi-buffer 128, which is provided for data flow with a required maximum data age of 2, the buffer index is switched such that the buffer with a data age of 0 in the previous cycle is treated as the buffer with a data age of 1, the buffer with a data age of 1 in the previous cycle is treated as the buffer with a data age of 2, and the buffer with a data age of 2 in the previous cycle is treated as the buffer with a data age of 0 (exchange in Fig. 7).

[0081] Fig. 18 is a processing flow of the data-age-compatible buffer reference unit 126. Each step is described below. (FIG. 18: Step 1261)

[0082] The data-age-compatible buffer management unit 123 reads the buffer index 124. (FIG. 18: Step 1262)

[0083] The data-age-compatible buffer management unit 123 copies the value of the buffer corresponding to buffer index 124 into the local buffer 127. At this time, since buffer index 124 specifies a reference target of the data age requested by application 125, a desired data value of the data age can be referenced.

[0084] Fig. 19 is a processing flow of the data-age-compatible buffer update unit 129. The data-age-compatible buffer update unit 129 determines an update target of the multi-buffer 128 according to the data age based on the buffer index 124. Each step is described below. (FIG. 19: Step 1291)

[0085] The data-age-compatible buffer update unit 129 reads the buffer index 124. (FIG. 19: Step 1292)

[0086] The data-age-compatible buffer update unit 129 copies the output value of application 125 into a buffer corresponding to buffer index 124. Specifically, the buffer with a data age of 0 is specified using buffer index 124, and the output value of application 125 is copied.

[0087] Fig. 20 is a processing flow of application unit 125. Each step is described below. (FIG. 20: Step 1251)

[0088] The application unit 125 copies the value of the multi-buffer 128 into the local buffer 127 using the data-age-compatible buffer reference unit 126. (FIG. 20: Step 1252)

[0089] The application unit 125 performs a tax calculation using an input value stored in the local buffer 127. (FIG. 20: Step 1253)

[0090] The application unit 125 uses the data-age-compatible buffer update unit 129 to update the value of the multi-buffer 128 to a result of the tax calculation. (FIG. 20: Step 1254)

[0091] Application unit 125 issues an event based on software execution information 112. For example, if the user is A3, an event is issued to start A5. A5 is started when events A2 and A3 match.

[0092] According to Example 1, the plurality of CPUs (computing devices) 13 are designed to execute the second time-synchronous application, which has a dependency relationship with the first time-synchronous application, within one cycle in which the first time-synchronous application is executed. Therefore, it is possible to provide the vehicle's internal control device that can determine the data age for the input data of the time-synchronous application, reference a recent value within the time-synchronous application itself, and reduce latency.

[0093] According to Example 1, it is possible to determine the data age based on the data flow and software execution information, and maintainability is improved.

[0094] As shown in Example 1, it is possible to capture a data flow in which jitter occurs in the data age, and maintainability is improved.

[0095] As shown in Example 1, it is possible to automatically correct a data flow in which jitter occurs in a data age and improve design efficiency while preventing human error.

[0096] According to Example 1, data communication within a LET interval between time-synchronized applications can be performed using data access that corresponds to the data age, and the latency from an input to an output in a system can be reduced.

[0097] Furthermore, as shown in Example 1, input and output times between applications are essentially determined by exchanging the multibuffer, which is executed at the beginning of a cycle. Therefore, even if the application is moved to a different kernel, it is sufficient to verify whether the application terminates within a cycle. Since an impact analysis on other applications becomes unnecessary, design efficiency can be improved.

[0098] The number of CPUs (computing devices) 13 that run the second time-synchronous application, which has a dependency relationship with the first time-synchronous application, within the cycle in which the first time-synchronous application is run, can be one or two. <Beispiel 2>

[0099] Next, Example 2 of the present invention will be described.

[0100] Example 2 is an example where the software execution information is corrected so that the data age estimate becomes a data age expectation when the data age estimate differs from the data age expectation. Differences from Example 1 are described.

[0101] Fig. Figure 21 is a diagram showing a configuration of an in-vehicle control device 2 according to Example 2. The in-vehicle control device 2 includes an ECU 22 and a development environment 21.

[0102] Fig. Figure 22 is a diagram showing a functional block of the vehicle's internal control device 2 according to Example 2. In Example 2, a data age synchronization correction unit 215 compares a data age estimate 214 with a data age expectation 217. If the values ​​are different, software execution information is updated based on software execution information 212 so that the data age expectation 217 is met, and then software execution correction information 218 is output. A corrected data age is output as data age correction information 216.

[0103] Fig. 23 is a processing flow of the data age synchronization correction unit 215. Each step is described below. (FIG. 23: Step 2151)

[0104] The data age synchronization correction unit 215 reads the data age estimate 214, the data age expectation 217, and the software execution information 212. (FIG. 23: Step 2152)

[0105] The data age synchronization correction unit 215 compares the data age estimate 214 with the data age 217 and determines whether there is a data flow with a different data age value. If so, the process proceeds to step 2153. If not, the process proceeds to step 2156. (FIG. 23: Step 2153)

[0106] The data age synchronization correction unit 215 determines whether the data age expectation value of the target data flow is 0. If so, the process proceeds to step 2154. If not, the process proceeds to step 2155. (FIG. 23: Step 2154)

[0107] The data age synchronization correction unit 215 changes a start condition of a receiving application of the data flow to an event and corrects the value of the data age of the corresponding data flow to 0. (FIG. 23: Step 2155)

[0108] The data age synchronization correction unit 215 changes the start condition of the receiving application of the data flow to a time and corrects the value of the data age of the corresponding data flow to an expected value. (FIG. 23: Step 2156)

[0109] The data age synchronization correction unit 215 outputs the start condition that was corrected in this process, based on the software execution information 212, as the software execution correction information. (FIG. 23: Step 2157)

[0110] The data age synchronization correction unit 215 outputs the value of the data age that was corrected in this process, based on the data age estimate 214, as the software execution correction information.

[0111] Fig. Figure 24 shows an example of the software execution information 212 according to Example 2.

[0112] Fig. Figure 25 shows an example of the data age estimate 214 according to Example 2.

[0113] Fig. Figure 26 shows an example of the data age expectation value 217 and the data age correction information 216 according to Example 2.

[0114] Fig. Figure 27 shows an example of the software execution correction information 218 according to Example 2.

[0115] Fig. 28 is a data age-compatible data access flow in which a multi-buffer is used according to Example 2.

[0116] According to Example 2, in addition to the effects similar to those of Example 1, if the data age estimate does not match the data age expectation, the software execution information is corrected to automatically assume the expected value, so an improvement in design efficiency can be expected. <Beispiel 3>

[0117] Next, Example 3 of the present invention will be described.

[0118] In this example, an application explicitly defines a data age based on Example 2. Differences from Examples 1 and 2 are described.

[0119] In Example 2, the data-age-compatible buffer management unit 123 identifies the age of data to which the application wishes to refer, based on the data age estimate 214 or the data age correction information 216, and updates the buffer index 124 of the multi-buffer, which is a buffer of the data age expectation value 217, and at least the second time-synchronous application refers to the data age buffer using a data-age-compatible buffer reference unit 326.

[0120] In the data-age-compatible buffer management unit 123, the first time-synchronous application or the second time-synchronous application sets the data age and the data-age-compatible buffer reference unit 326 is used.

[0121] Fig. Figure 29 is a diagram showing a configuration of an in-vehicle control device 3 according to Example 3. The in-vehicle control device 3 includes an ECU 32 and a development environment 31.

[0122] Fig. Figure 30 is a diagram showing a functional block of the vehicle's internal control device 3 according to Example 3. Fig. 30 An application 325 explicitly sets a data age and accesses the multi-buffer 128 through the data-age-compatible buffer reference unit 326 and a data-age-compatible buffer update unit 329.

[0123] Fig. Figure 31 shows a processing flow of the data-age-compatible buffer reference unit 326. Each step is described below. (FIG. 31: Step 3261)

[0124] The data-age-compatible buffer reference unit 326 reads the buffer index 124. (FIG. 31: Step 3262)

[0125] The data-age-compatible buffer reference unit 326 reads the specified data age, which serves as an argument. (FIG. 31: Step 3263)

[0126] The data-age-compatible buffer reference unit 326 reads (copies) a value from the buffer corresponding to the buffer index 124 and the specified data age into the local buffer 127.

[0127] Fig. 32 is a processing flow of the data-age-compatible buffer update unit 329. Each step is described below. (FIG. 32: Step 3291)

[0128] The data-age-compatible buffer update unit 329 reads the buffer index 124. (FIG. 32: Step 3292)

[0129] The data-age-compatible buffer update unit 329 reads the specified data age, which serves as an argument. (FIG. 32: Step 3293)

[0130] The data-age-compatible buffer update unit 329 copies the output value into the buffer that corresponds to the buffer index 124 and the specified data age.

[0131] Fig. 33 is a processing flow of application unit 325. Each step is described below. (FIG. 33: Step 3251)

[0132] The application unit 325 sets a data age and copies the value of the multi-buffer to the local buffer 127 using the data-age-compatible buffer reference unit 326. (FIG. 33: Step 3252)

[0133] Application unit 325 performs a control calculation using the input value of the local buffer 127. (FIG. 33: Step 3253)

[0134] The application unit 325 sets a data age and updates the value of the multi-buffer using the data-age-compatible buffer update unit 329 to a result of the tax calculation. (FIG. 33: Step 3254)

[0135] Application unit 325 outputs an event based on software execution information.

[0136] According to Example 3, in addition to the effects similar to those of Example 1, since the multi-buffer can be referenced from the application by setting the data age and can be updated, the data-age-compatible buffer reference unit and the data-age-compatible buffer update unit corresponding to each data age are unnecessary, and an improvement in implementation efficiency and a reduction in memory consumption can be expected. <Beispiel 4>

[0137] Next, Example 4 of the present invention will be described.

[0138] Example 4 integrates a development environment based on Example 1 into an ECU. Differences compared to Examples 1, 2, and 3 are described.

[0139] Fig. Figure 34 is a diagram showing a configuration of an in-vehicle control device 4 according to Example 4. The in-vehicle control device 4 includes an ECU 42.

[0140] Fig. Figure 35 is a diagram showing a functional block of an in-vehicle control device according to Example 4.

[0141] According to Example 4, in addition to effects similar to those of Example 1, the development environment is integrated into the ECU 42. Therefore, if a function is added to the vehicle's internal control unit 4 after the sale, each ECU can automatically execute a design modification for the added application. Thus, an improvement in design efficiency can be expected. <Beispiel 5>

[0142] Next, Example 5 of the present invention will be described.

[0143] In Example 5, the development environment based on Example 2 is integrated into an ECU. Differences compared to Examples 1, 2, 3, and 4 are described.

[0144] Fig. Figure 36 is a diagram showing a configuration of an in-vehicle control device 5 according to Example 5. The in-vehicle control device 5 includes an ECU 52 (control unit).

[0145] Fig.Figure 37 is a diagram showing a functional block of the vehicle's internal control device 5 according to Example 5.

[0146] According to Example 5, in addition to effects similar to those of Example 1, a development environment is integrated into the ECU 52. Therefore, if a function is added to the vehicle's internal control unit 5 after the sale, each ECU can automatically perform a design modification for the added application based on an expected value. Thus, an improvement in design efficiency can be expected. Reference symbol list 1, 2, 3, 4, 5 vehicle-internal control device 11 development environment 12, 52 ECU (control unit) 13 CPU (Computer) 14 storage 15 Network 16 Sensor 17 Actuator 42 52 ECU 111 Data flow information 112 Software execution information 113 Data age calculation unit 114, 214 Data age estimate 115, 215 Data Age Synchronization Correction Unit 116, 216 Data age correction information 121 Application Launch Management Unit 122 cycle counter 123 data age-compatible buffer management unit 124 Buffer index 125, 325 application unit 126, 326 data age-compatible buffer reference unit 127 local buffer 128 Multi-buffer 129, 329 data age-compatible buffer update unit 212 Software execution information 214 Data age estimate 216 Data age estimation information 217 Data age expected value 218 Software Execution Correction Information A1 to A11 Application QUOTES INCLUDED IN THE DESCRIPTION

[0000] This list of documents cited by the applicant was automatically generated and is included solely for the reader's convenience. The list is not part of the German patent or utility model application. The DPMA accepts no liability for any errors or omissions. Cited patent literature

[0000] JP 2022-14679 A

[0009]

Claims

[1] Vehicle-internal control device comprising: a variety of computing devices and a control unit designed to control the multitude of computing devices, wherein the control unit controls the multitude of computing devices in such a way that they execute a second time-synchronous application, which has a dependency relationship with a first time-synchronous application, within a cycle in which the first time-synchronous application is executed. [2] Vehicle-internal control device according to claim 1, further comprising: a multi-buffer comprising at least one buffer that complies with a data age of the data to be managed is defined, where the first time-synchronous application is output to the multi-buffer and the second time-synchronous application refers to the buffer in accordance with the data age. [3] Vehicle-internal control device according to claim 2, further comprising: a cycle counter designed to identify the passage of time; an application launch management unit designed to periodically update the cycle counter; a data-age-compatible buffer management unit designed to update a buffer index specifying a multi-buffer access target corresponding to the data age, based on the cycle counter; a data-age-compatible buffer reference unit designed to determine a multi-buffer reference target in accordance with the data age based on the buffer index; and a data age-compatible buffer update unit designed to determine a multi-buffer update target in accordance with the data age based on the buffer index. [4] Vehicle-internal control device according to claim 2, further comprising: a data age calculation unit designed to calculate the data age for at least one data unit exchanged between applications, based on data flow information and software execution information, and to output the data age as a data age estimate; and a data age synchronization correction unit designed to correct the data age so that the data age assumes a constant value and is either high or low when jitter occurs in the data age estimate. [5] Vehicle-internal control device according to claim 2, further comprising: a data age calculation unit designed to calculate the data age for at least one data unit exchanged between applications, based on data flow information and software execution information, and to output the data age as a data age estimate; and a data age synchronization correction unit designed to compare the data age estimate with a data age expectation value, to update the software execution information to meet the data age expectation value, and to output data age correction information and software execution correction information. [6] In-vehicle control device according to claim 3, wherein the data age-compatible buffer management unit identifies the age of data to which an application wishes to refer based on a data age estimate or data age correction information and updates the buffer index of the multi-buffer, which is a buffer of a data age expectation value, and at least the second time-synchronous application refers to the data age buffer using the data age-compatible buffer reference unit. [7] In-vehicle control device according to claim 3 or 6, wherein in the data-age-compatible buffer management unit the first time-synchronous application or the second time-synchronous application sets a data age and uses the data-age-compatible buffer reference unit. [8] In-vehicle control device according to claim 2, wherein the data age is expressed with relative data age information in which a difference in execution time between applications in which a data reference relationship occurs is expressed as a relative relationship.

Images