US20070214451A1 - Method and Device for the Stimulation of Functions for Controlling Operating Sequence - Google Patents
Method and Device for the Stimulation of Functions for Controlling Operating Sequence Download PDFInfo
- Publication number
- US20070214451A1 US20070214451A1 US10/578,341 US57834104A US2007214451A1 US 20070214451 A1 US20070214451 A1 US 20070214451A1 US 57834104 A US57834104 A US 57834104A US 2007214451 A1 US2007214451 A1 US 2007214451A1
- Authority
- US
- United States
- Prior art keywords
- functions
- program
- software
- function
- global variable
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
- 230000006870 function Effects 0.000 title claims abstract description 190
- 238000000034 method Methods 0.000 title claims abstract description 100
- 230000000638 stimulation Effects 0.000 title claims abstract description 28
- 230000015654 memory Effects 0.000 claims description 27
- 238000004590 computer program Methods 0.000 claims description 8
- 230000003213 activating effect Effects 0.000 claims description 4
- 230000004936 stimulating effect Effects 0.000 claims 5
- 238000012360 testing method Methods 0.000 description 39
- 238000011161 development Methods 0.000 description 21
- 230000004048 modification Effects 0.000 description 16
- 238000012986 modification Methods 0.000 description 16
- 230000001276 controlling effect Effects 0.000 description 9
- 238000010586 diagram Methods 0.000 description 7
- 230000007246 mechanism Effects 0.000 description 6
- 230000001105 regulatory effect Effects 0.000 description 6
- 230000008569 process Effects 0.000 description 5
- 230000005540 biological transmission Effects 0.000 description 4
- 238000002715 modification method Methods 0.000 description 4
- 230000008901 benefit Effects 0.000 description 2
- 230000009471 action Effects 0.000 description 1
- 230000004913 activation Effects 0.000 description 1
- 230000006978 adaptation Effects 0.000 description 1
- 238000004458 analytical method Methods 0.000 description 1
- 230000006399 behavior Effects 0.000 description 1
- 238000004422 calculation algorithm Methods 0.000 description 1
- 238000004364 calculation method Methods 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 238000006243 chemical reaction Methods 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 230000008878 coupling Effects 0.000 description 1
- 238000010168 coupling process Methods 0.000 description 1
- 238000005859 coupling reaction Methods 0.000 description 1
- 238000006880 cross-coupling reaction Methods 0.000 description 1
- 230000004069 differentiation Effects 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000005259 measurement Methods 0.000 description 1
- 230000004044 response Effects 0.000 description 1
- 238000013522 software testing Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G05—CONTROLLING; REGULATING
- G05B—CONTROL OR REGULATING SYSTEMS IN GENERAL; FUNCTIONAL ELEMENTS OF SUCH SYSTEMS; MONITORING OR TESTING ARRANGEMENTS FOR SUCH SYSTEMS OR ELEMENTS
- G05B15/00—Systems controlled by a computer
- G05B15/02—Systems controlled by a computer electric
Definitions
- the present invention is directed to a method and a device for the stimulation of functions for controlling operating sequences, in particular in a motor vehicle.
- the present invention is also directed to a corresponding control unit and a corresponding computer for function stimulation and the associated computer program as well as the corresponding computer program product.
- control unit software in particular in automotive control units for controlling the engine, brakes, transmission, etc.
- bypass application is a rapid prototyping method for developing and testing new control unit functions.
- development of functions is also possible with all other control unit applications, e.g., in the field of automation and machine tools.
- German Published Patent Application No. 101 06 504 describes a method and an emulation device for emulating control functions and/or regulating functions of a control unit or a regulating unit of a motor vehicle in particular.
- the functions are transferred to an external emulation computer, a data link being established via a software interface of the emulation computer and a software interface of the control unit/regulating unit before the start of emulation.
- the software interfaces should be configured for emulation of different control/regulating functions before the start of emulation without any change in software.
- German Published Patent Application No. 102 28 610 describes a method and a device for testing a control program by using at least one bypass function in which the control program is executed together with the at least one bypass function on an electric computing unit.
- the bypass functions are coupled to preselected interfaces via dynamic links.
- bypass breakpoint i.e., software breakpoint
- a bypass breakpoint describes exactly the location in a software function where the content of a control unit variable is not described by the software program but instead is described via detours, e.g., via a bypass software function.
- Software breakpoints are highly individual and in the normal case are not part of a control unit software program because memory resources are used for this.
- a function developer requires a control unit program having software breakpoints, these are incorporated into a program version only after the development department has been commissioned.
- the software development manually modifies the source code of the corresponding function and, by running a compiler and link, creates a new control unit program which is used explicitly for the prototyping application.
- a comparable method is based on the idea of replacing only the store instructions (write access to a control unit variable) via jump instructions to a subfunction.
- the store instructions may already be 16 bits because addressing is performed indirectly via address registers.
- These 16-bit instructions cannot be used to call a subfunction because a direct address-oriented call of a subfunction requires a 32-bit jump instruction. Therefore, the method according to the related art is usable only to a limited extent and may be used only with microprocessors having a strict 32-bit instruction set.
- the store instruction has a fixed bit width, flexibility with regard to the function development is greatly restricted here. This is also true when a certain store instruction must not be manipulated at all for other reasons, so that populating in this way via a jump instruction to a subfunction is then not possible at all.
- control unit software In function development for control unit software as mentioned above, testing of software functions is performed on laboratory vehicles (measurement sites) or via appropriate software testing environments (module test). When performing tests on laboratory vehicles, the control unit inputs are stimulated from the outside by electric signals to thereby observe and measure the corresponding responses of the control unit and the software. In the case of the available software test environments for the module tests, only the software functions to be investigated are considered in a stand-alone operation within the test environment without taking into account feedback effects or cross-coupling with the system as a whole.
- the object of the present invention is to stimulate software functions in an integrated state within a software program in runtime and to test them and thus overcome the aforementioned problems in the related art.
- the present invention is directed to a device and a method for the stimulation of functions for controlling operating sequences, where the functions access at least one global variable of at least one program for control, at least one stimulation function which accesses the at least one global variable via at least one software breakpoint being advantageously provided.
- the functions are expediently stimulated within the program during the runtime of the program, in particular in real time within a runtime system.
- the global variable is assigned a first piece of data information and this first piece of data information is replaced by a second piece of data information corresponding to the new stimulation values.
- the stimulation of functions is preferably within the scope of the present invention for the stimulation of functions to be accomplished by an internal bypass, with the software breakpoint being accomplished by assigning address information to the global variable, the address information being loaded from a memory means by a load instruction and the address information of the global variable of the load instruction being replaced.
- the address information of the global variable is advantageously replaced by the address information of a pointer variable, an initial address of the function being determined from the address information, and the functions for control of operating sequences being replaced by replacing the address information with additional functions.
- the software breakpoint may also expediently be accomplished by having the global variable addressed by a store instruction and the store instruction manipulated onto the global variable by replacing the store instruction with a jump instruction and replacing the functions for control of the operating sequences with additional functions by replacing the store instruction with the jump instruction.
- the present invention expediently uses “dynamic hooks” of software breakpoints without any changes in source code.
- the methods described for accomplishing this modify the address information of load instructions, modify the function calls and insert new program codes. These modifications are performed on an existing software program version, e.g., on the basis of targeted HEX code modifications.
- the address information of the global variable is replaced by the address information of a pointer variable, the address information of the pointer variable being in a reserved memory area, in particular of the memory means in the control unit.
- a store instruction is advantageously manipulated onto the global variable by replacing the store instruction with a jump instruction.
- the functions for control of the operating sequences are expediently replaced and/or expanded by replacing the store instruction with the jump instruction through additional functions.
- the present invention describes a control unit containing such a device and makes it the object of the present invention along with a computer program suitable for execution of such a method.
- This computer program is executed on a computer, in particular an application control unit system according to the present invention or an application PC.
- the computer program according to the present invention may be stored on any machine-readable medium.
- Such a computer-readable data medium or machine-readable medium may be in particular a diskette, a CD-ROM, a DVD, a memory stick or any other portable memory medium.
- memory media such as ROM, PROM, EPROM, EEPROM or flash memories and volatile RAM memories, etc., are also possible for storage.
- the choice of memory medium, i.e., the machine-readable medium is thus not to be regarded as restrictive with respect to the computer program product as the object of the present invention.
- the various rapid prototyping methods, software test methods and data calibration methods are rendered more rapidly usable and more flexible in handling.
- the software breakpoints are used without tying up software development capacity. This results in a lower technical and administrative complexity on the whole and therefore reduces costs.
- microprocessor types having a mixed instruction set of 16/32-bit CPU instructions, for example, may be supported.
- control unit function to be investigated is advantageously stimulated automatically by the integrated test software within the runtime system.
- the advantages of the object according to the present invention also include the fact that for the stimulation of the control unit function, no electric signals need be applied to the control unit from the outside. Another advantage is that the calculated output values of the stimulated control unit function are directly available again to the real time system. Thus, for example, complex control algorithms within the control unit may be investigated and tested in greater detail and developed further if necessary.
- FIG. 1 shows a system or a device according to the present invention for adapting the functions.
- FIG. 2 illustrates the sequence for determining the breakpoints or software breakpoints in the program.
- FIG. 3 shows an overview and a selection of various methods for modification of the load instructions and/or the store instructions.
- FIG. 4 shows a program diagram for a first and preferred modification method of the load instruction.
- FIG. 5 illustrates a program diagram for a second modification method of the store instruction.
- FIG. 6 illustrates a program diagram for a third modification method of the store instruction.
- FIG. 7 illustrates a program diagram for a fourth modification method of the store instruction.
- FIG. 8 shows a schematic diagram for adjusting the calls of the functions for controlling the operating sequences.
- FIG. 9 shows the hook function for tying in the additional functions.
- FIG. 10 shows a schematic diagram of the memory segments in the memory means with regard to the hook function.
- FIG. 11 shows in greater detail a complete development process according to the present invention.
- FIG. 12 shows the internal bypass, in particular the procedure of dynamic linking.
- FIG. 13 illustrates a basic diagram for the stimulation of functions.
- FIG. 14 shows a flow chart for creating the test sequence software.
- FIG. 15 shows the development process according to the present invention.
- FIG. 1 shows a schematic diagram of an application arrangement having a control unit 100 and an application system 101 , which are connected to interfaces 103 and 104 via a link 102 .
- This link 102 may be designed to be wired or wireless.
- a microprocessor 105 is shown in particular having a mixed instruction set.
- Memory means 106 includes an address register 108 , a data register 107 and a memory area for the at least one program to be adapted with regard to functions.
- the control means for implementing the present invention may be contained in the application system and/or represented by it or designed using the microprocessor itself. Likewise, memory means for implementation of the present invention may also be situated outside the control unit, in particular in the application system.
- the object according to the present invention is implementable using the device shown here.
- the functions may be adapted using an external bypass, the advantageous embodiment is to perform the adaptations internally in such a way that they are tied into the program run and therefore there are dynamic hooks for software interventions without any source code changes.
- the object described here modifies the address information of load instructions, modifies the content of store instructions, modifies the address information of function calls and adds new program codes.
- the method described below is based on the use of microcontrollers having a mixed instruction set, in particular 16/32-bit CPU instructions.
- the TriCore TC17xx microcontroller (RISC/DSP/CPU) from Infineon is the example used here; it is a component of a control unit for controlling operating sequences, in particular in a motor vehicle, e.g., for engine control or for controlling the steering, transmission, brakes, etc.
- this method may also be used with microprocessors having a non-mixed instruction set, in particular in pure 32-bit microprocessors (RISC processors, e.g., PowerPC/MPC5xx).
- RISC processors e.g., PowerPC/MPC5xx.
- the code generator of the compiler arranges the machine instructions sequentially. This is understood to refer to the sequential arrangement of instructions for loading address information of an indirectly addressed control unit variable, for example, into the corresponding address registers. In contrast, in the case of a directly addressed variable, the address information is in the instruction itself. This is the case with most compilers.
- control unit software program which is available in the form of a hex code file, for example.
- Additional files may include a data description file (e.g., ASAP) and a linker file (e.g., ELF binary) which supply information about control unit variables and control unit functions.
- a data description file e.g., ASAP
- a linker file e.g., ELF binary
- a disassembler software program e.g., a Windows software program
- the hex code file is disassembled.
- the corresponding addresses of the control unit variables to be bypassed are taken from the data description file or from a reference databank created for the method.
- the disassembler program created according to the present invention e.g., a Windows software program, seeks the corresponding access instructions to the control unit variables (load/store instructions) in the disassembled program code with the assistance of the address information of these variables being sought, which affect the content of the variables.
- This disassembler program as a Windows software program is a simulation program which checks the register contents after each assembler instruction. If a store instruction is localized and the content of the loaded address register corresponds to the address value of the control unit being sought or if the memory destination of the store instruction corresponds to the variable address, then this is a source where the content of the control unit variables is modified.
- the manner in which the program code is modified at the source depends on the particular type of addressing of the control unit variables.
- FIG. 2 which shows control unit program code 201 and software function 202 .
- Arrows 203 symbolize the method described here for determining the store instructions.
- Store instruction 204 of a variable access is shown in such a way that in the case of direct addressing, the memory destination of the store instruction is the RAM address, and in the case of indirect addressing, the content of the address register corresponds to the RAM address, so the load instructions may then be determined.
- Arrows 205 represent the method described here for determining the load instructions.
- Load instructions 206 are for loading the variable addresses, specifically the global variables.
- the load instruction sources and/or the store instruction sources are localized according to different types of addressing and then the control unit function in which the sources are located is determined for these sources, so that all the function calls in the entire program code may be accomplished through function calls of the newly created hook function(s), so that the original function call of the control unit function may take place within the corresponding hook function.
- microcontroller(s) described here there are a number of different types of addressing in a wide variety of embodiments. It is possible to minimize this variety.
- FIG. 3 shows an overview of the different methods for modifying the load and/or store instructions.
- Method 1 involves, for example, a 16-bit store instruction and indirect addressing. Starting from the position of the found store instruction, the points are traced back in the disassembled program code until the particular load instructions are determined. The found load instructions are the deciding factor for this method. This method is used not only in problems with a mixed instruction set but also when for other reasons it is impossible to replace the store instruction with a jump instruction.
- the determined load instructions are replaced by address information of a pointer variable.
- This pointer variable is generated via a development environment, in particular the DHooks development environment.
- the address of the pointer variable is in a reserved free area of the memory means, the memory layout for variables.
- the modified load instructions address the same address register as the original instructions.
- the difference in the modified load instructions is in the type of addressing of the address register and the address information.
- FIG. 4 illustrates method 1 in a schematic diagram showing original program code 401 and modified program code 411 .
- the control unit function, function_a() here is formed by 402 , 406 and 417 , 407 .
- the instructions, i.e., instruction sequences, are shown in 402 and 417 , respectively, and the actual functionality is shown in 406 and 407 .
- This shows access axx% to an address register (e.g., a 0 through a 15 in the case of a 16-bit width) and access dxx% to a data register (e.g., d 0 through d 15 in the case of a 16-bit width).
- movh.a and ld.a load instructions
- st.x store instruction
- 408 , 409 , 410 , 413 , 414 and 415 movh.a and ld.a are shown as 32-bit instructions (see 412 and 403 ).
- Store instruction st.x is shown as a 16-bit instruction (see 405 ) and therefore is not replaceable with a 32-bit jump instruction in this example. As stated previously, this also applies to all other cases in which such a replacement is impossible or undesirable.
- the novel instruction code according to the present invention i.e., program code 403
- the address of the control unit variable is replaced by the address of the pointer variable according to 404 .
- the method of creating additional program code i.e., additional functions, is explained in greater detail below according to the four methods.
- FIG. 5 shows in greater detail the modification of the program points according to method 2 .
- Original program code 501 and modified program code 511 are shown.
- the control unit function, function_a() here, is formed by 502 , 506 and 517 , 507 . Instructions and/or instruction sequences are shown in 502 and 517 , and the actual functionality is shown in 506 and 507 .
- Access %axx to an address register e.g., a 0 through a 15 in the case of a 16-bit width
- access %dxx to a data register e.g., d 0 through d 15 in the case of a 16-bit width
- instructions movh.a and ld.a load instructions
- st.x store instruction
- Store instruction st.x is now shown as a 32-bit instruction (see 505 ) and is thus replaceable in this example by a 32-bit jump instruction jla.
- the novel instruction code according to the present invention i.e., program code 503 (jla: jump instruction), is now input into 505 .
- Method 2 is a 32-bit store instruction in conjunction with indirect addressing.
- the 32-bit store instruction is replaced by an absolute jump instruction jla 512 to a software balcony function (balcony_M 2 ) (see call 520 of the software balcony function).
- jla jump instruction With the jla jump instruction, the jump back address is stored in register a 11 (see 521 ).
- This program code generated in the DHooks development environment, is referred to as a balcony function.
- the balcony functions include additional initializing, copying and breakpoint mechanisms and are used as software functions to expand the breakpoint functionality. Balcony functions are used for breakpoint methods 2 , 3 and 4 .
- the sequence then jumps back into control unit function according to 522 via the jump back address stored in address register a 11 via an indirect jump.
- FIG. 6 shows in greater detail the modification of the program points according to method 3 .
- Original program code 601 and modified program code 611 are shown.
- the control unit function, function_a() here is formed by 602 , 607 and 617 , 607 .
- the instructions, i.e., instruction sequences, are shown in 602 and 617 , respectively, and the actual functionality is shown in 606 and 607 .
- a special st.x store instruction
- st.t store instruction
- Store instruction st.t is now depicted as a 32-bit instruction (see 605 ) and thus is replaceable in this example by a 32-bit function call (call balcony_M 3 ).
- the novel instruction code according to the present invention i.e., program code 603 (call: function call), is now input into 605 .
- a 32-bit store instruction st.t is used in combination with direct addressing 618 (store instruction having address 610 ).
- the 32-bit store instruction is replaced by a 32-bit function call (call balcony_M 3 , 603 ) of a software balcony function (balcony_M 3 , 621 ) (see 604 ).
- Software balcony function 621 includes the query of a breakpoint and the store instruction in the original state. With an activated breakpoint, no store instruction is executed. This variable is thus uncoupled from the control unit function. To do so, call 620 for balcony function 621 is carried out from 612 . Jump back 622 to the control unit function takes place via the address of the control unit variable (adr. of ecu variable) 619 .
- FIG. 7 shows the modification of the program points according to method 4 in more detail.
- Original program code 701 and modified program code 711 are shown.
- the control unit function, function_a() here is formed by 702 , 706 and 717 , 707 .
- the instructions, i.e., instruction sequences, are shown in 702 and 717 , respectively, and the actual functionality is shown in 706 and 707 .
- Access %axx to an address register and access %dxx and/or %dyy to a data register are shown.
- Store instruction st.x is shown as a 32-bit instruction (see 705 ) and is thus replaceable in this example by a 32-bit jump instruction.
- the novel instruction code according to the present invention i.e., program code 703 (jla: jump instruction), is now input into 705 .
- Method 4 uses a 32-bit store instruction st.x ( 710 ) in combination with direct addressing ( 718 ).
- the 32-bit store instruction is replaced by a 32-bit jump instruction jla (jla balcony_M 4 — a ).
- the jump instruction points to software balcony function 1 (balcony_M 4 — a (), 721 ) which is called with 720 .
- software balcony function 1 721 the content of the previously loaded data register %dxx is stored temporarily in a temporary DHook variable (iB_TmpMsg_xxx).
- Another balcony function (balcony_M 4 _b(), 724 ) is called from 721 with 723 via a function “call.”
- This second software balcony function 2 contains the actual breakpoint as in method 3 .
- Software balcony function 724 contains the query of the breakpoint. When the breakpoint is deactivated, the content of temporary variable iB_TmpMsg_xxx is written back into the control unit variable (see 725 ). When the breakpoint is active, there is no rewriting. The control unit variable is thus uncoupled from the control unit function. The jump back to the control unit function then takes place via/22.
- control unit function in which the sources are located is determined. This is done using the Windows software program developed for this method; on the basis of the position of the load/store instructions and with the help of reference information, it determines the corresponding beginning and end addresses of the control unit function.
- the original function call of the control unit function is performed within the corresponding hook function.
- FIG. 8 uses the same diagram as that in the previous FIGS. 2, 4 , 5 , 6 and 7 to make this illustration of the modification comparable.
- Original control unit program code 801 and modified program code 811 are shown.
- a task list task_list is used and a corresponding extra function or subfunction subfunction_x() is used.
- the procedure 804 according to FIG. 2 is used to determine the function addresses and function calls.
- the address of function_a is replaced by the address of hook_function_a.
- the function call of function_a is replaced by the call of hook_function_a.
- the indirect function call of function_a is replaced by a call of hook_function_a (as a 32-bit instruction here).
- the newly formed program code with the replacements is indicated by nP.
- FIG. 9 shows a schematic diagram of such hook functions, hook_function_a() and hook_function_x().
- Control unit program code 901 and memory area 902 for additional program code are shown.
- Actual hook functions 903 and possible initialization 904 of any pointer variable needed are also shown.
- Program code 905 is for the software breakpoints, the configuration and tie-in of the rapid prototyping methods in particular.
- call 906 of original control unit function function_a() is shown. This is comparable for second hook function hook_function_x() but is not shown again for reasons of simplicity.
- the hook function thus includes the breakpoint mechanism which controls access to a rapid prototyping method via application data.
- initialization of pointer variables and function call of the actual control unit function are performed in the hook function if necessary.
- hook functions are described below as a function of the breakpoint methods.
- the pointer variable Before a store instruction to a control unit variable addressed by a pointer may be described appropriately, the pointer variable must be addressed using a variable address.
- the pointer is initialized in the hook function. If the breakpoint access is not active, the pointer is initialized using the address of the control unit variable. If the breakpoint access is active, the pointer is initialized using the address of a temporary DHooks variable. At this point, write access is diverted to the temporary variable, e.g., in the case of indirect addressing of the control unit variable.
- the hook function includes the mechanism for controlling the software breakpoint and the function call of the original control unit function.
- Dedicated memory areas of the memory means in memory layout S 1 of the control unit software program are needed for the breakpoint method.
- the method shows free areas for code (DHook code) S 4 , data (DHook data) S 3 and RAM (DHook-RAM) S 2 .
- the breakpoint functions are stored in the code area, and application variables by which the breakpoint mechanism is controlled are stored in the data area.
- the pointer variables and administrative RAM variables needed for the method are stored in the free area for RAM variables.
- the software breakpoint code is generated automatically via a development environment created for the method and is illustrated again in FIG. 11 .
- the variables in point 8 may also be selected automatically according to specifiable criteria.
- the software breakpoint code is tied in, by a hex-code merge run, for example In this action, the results (hex codes) of the development environment for the dynamic breakpoint method are copied into free areas of the original software program (hex code).
- the method has a structure similar to that of the internal control unit bypass in which hex code information from two separate software development runs is joined together.
- Coupling of the bypass program which includes at least one bypass function is performed by dynamic linking to predetermined interfaces in the control program. In this way, it is possible to access data present in the electronic computer unit during the program sequence of the control program.
- FIG. 12 illustrates the dynamic linking of the bypass functions.
- a first block 60 reflects the vector table available to the control program. This figure shows a first column (vector) 62 and a second column (channel) 64 .
- the first column 62 contains references on the basis of which a decision is made as to which bypass function is to be activated.
- the second column 64 contains information about whether it is an internal or external bypass.
- a second block 66 gives a table of function pointers containing a number of bypass functions to be activated.
- a third block 68 represents bypass services.
- a fourth block 70 and a fifth block 72 stand for activated bypass functions and a sixth block 74 stands for the control program.
- control program 74 Potential intervention points for the bypass functions are provided in control program 74 . This is accomplished by activating a driver layer (bypass services).
- the application system loads the bypass functions into the memory of the ECU. References to the bypass functions are then entered by the application system into table 66 of the function pointers.
- bypass services 68 in the ECU decide on the basis of entries in vector table 60 which intervention is active, i.e., which bypass function must be activated and where the reference to the bypass function is stored, as indicated by arrows 76 .
- bypass services 68 execute the two active bypass functions 70 and 72 (arrow 80 ). With activated bypass functions 70 and 72 , certain selected data 82 in control program 74 is accessed, as indicated by arrows 84 .
- bypass functions 70 and 72 In data transmission to bypass functions 70 and 72 , the latter access their input variables and parameters (application values) via address references. Bypass functions 70 and 72 thus have read access to all data 82 statically present in the ECU.
- the bypass drivers receive a reference to the stimulatable data flow in the data transmission of the control program, i.e., user software 74 . In this way the data consistency requirements may be met.
- the present invention relates to a software test method with which test sequences are generated according to the user's specifications in a test environment by using the methods of dynamic hooks (automatic software breakpoint) and internal bypass (rapid prototyping method) and these test sequences are run within the control unit software.
- dynamic hooks automated software breakpoint
- internal bypass rapid prototyping method
- the test description i.e., the test sequence over time, is generated in a program writing language developed for the method within the development environment created for the method.
- the source code thereby generated, describing the test sequence is translated via a compiler and linking procedure into a runnable software program for the target hardware (control unit).
- the test sequence code is integrated and executed according to the internal bypass method.
- RAM variables In investigating a control unit function, the corresponding input quantities (RAM variables) of the software function are bypassed.
- the bypassed RAM variables are stimulated via the integrated test sequence program in the control unit software. Scheduling for the call of the test sequence code may be specified in the development environment.
- the bypassed RAM variables are accessed via references.
- FIG. 13 schematically shows such a stimulation.
- a corresponding control unit function(s) 91 is(are) shown.
- Interface variables i.e., input variables 92 (inp 1 , inp 2 , inp 3 ) which are calculated in other functions, i.e., software functions, for example, and are available as global variables in the system, are also shown.
- Three of the software breakpoints 93 already mentioned that are expediently activated via the application system (in particular 101 in FIG. 1 ) are also shown.
- Stimulation values 95 (inp 1 s , inp 2 s , inp 3 s ) and/or their data information are available from the test sequence software, i.e., stimulation functions 94 , as a replacement within the context of the breakpoint for the interface variables, i.e., input variables 92 , and are blended in on activation of the breakpoints.
- control unit software 96 itself is shown.
- test sequence is specified in a test description language developed for the method.
- the input variables of the control unit function are brought to defined states.
- Various combinations of stimuli values, ramps or curves may be specified.
- the behavior over time is controlled via corresponding software functions within the description language.
- FIG. 14 shows an example of such a test sequence description.
- FIG. 15 Shows the Development Process as the Object of the Present Invention:
- E 1 identifies the control unit software.
- E 2 shows the test function and information about the interface variables. This also includes the scope of testing and the interface information on the software function or function to be tested or stimulated.
- E 3 shows the bypass selection, i.e., the selection of bypass variables, and thus the software extent of the bypass.
- the dynamic hooks method is localized in E 4 as described previously.
- the program version having bypassed input variables of the software function to be tested or stimulated, i.e., the control unit program having the software breakpoints, is accommodated in E 5 .
- test sequence script is created, i.e., processed; this is the test description of the test sequence using a script language.
- Code translatable from the test script(s), in particular C code, is created by converter, i.e., code generator, in E 7 .
- This generated code i.e., the test sequence program code, is depicted in E 8 .
- Library functions in a library (LIB) for sequence control are shown in E 9 .
- E 10 shows the software test development environment for program code creation, i.e., the hex codes and application data.
- E 10 also includes the compiler/linker tool set so that finally the software for the test sequence in the control unit is generated in E 10 .
- A2L application data
- HEX actual test sequence software
- the merge procedure (A2l-HEX merge procedure) takes place in E 13 to generate the project software, having integrated software breakpoints, and the test sequence code.
- E 14 contains the application data description file having the project data, i.e., breakpoint data and the application data for the test sequence control.
- E 15 also contains the finished program version having the software breakpoints and the test sequence code.
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Automation & Control Theory (AREA)
- Stored Programmes (AREA)
- Debugging And Monitoring (AREA)
- Programmable Controllers (AREA)
Abstract
A method and a device for the stimulation of functions for controlling operating sequences are described, the functions accessing at least one global variable of at least one program for control, wherein at least one stimulation function accessing the at least one global variable via at least one software breakpoint is provided.
Description
- The present invention is directed to a method and a device for the stimulation of functions for controlling operating sequences, in particular in a motor vehicle. The present invention is also directed to a corresponding control unit and a corresponding computer for function stimulation and the associated computer program as well as the corresponding computer program product.
- In function development of control unit software, in particular in automotive control units for controlling the engine, brakes, transmission, etc., the bypass application is a rapid prototyping method for developing and testing new control unit functions. However, such development of functions is also possible with all other control unit applications, e.g., in the field of automation and machine tools.
- Two applications of external control unit bypass, as described in German Published Patent Application No. 101 06 504, for example, and internal control unit bypass applications, as described in German Published Patent Application No. 102 28 610, for example, may be used as development methods here.
- German Published Patent Application No. 101 06 504 describes a method and an emulation device for emulating control functions and/or regulating functions of a control unit or a regulating unit of a motor vehicle in particular. For emulation, the functions are transferred to an external emulation computer, a data link being established via a software interface of the emulation computer and a software interface of the control unit/regulating unit before the start of emulation. To greatly accelerate the development and programming of new control/regulating functions of the control unit/regulating unit, it is proposed that the software interfaces should be configured for emulation of different control/regulating functions before the start of emulation without any change in software.
- German Published Patent Application No. 102 28 610 describes a method and a device for testing a control program by using at least one bypass function in which the control program is executed together with the at least one bypass function on an electric computing unit. The bypass functions are coupled to preselected interfaces via dynamic links.
- Independently of these two methods and devices, interventions in the control unit software are necessary for applicability. Such interventions are referred to with the term bypass breakpoint or software breakpoint. A bypass breakpoint, i.e., software breakpoint, describes exactly the location in a software function where the content of a control unit variable is not described by the software program but instead is described via detours, e.g., via a bypass software function. Software breakpoints are highly individual and in the normal case are not part of a control unit software program because memory resources are used for this.
- If a function developer requires a control unit program having software breakpoints, these are incorporated into a program version only after the development department has been commissioned. For this purpose, the software development manually modifies the source code of the corresponding function and, by running a compiler and link, creates a new control unit program which is used explicitly for the prototyping application.
- The disadvantage of this method and/or the device as explained in the related art includes the long running time until availability of the rapid prototyping program version. An important factor here is the high technical and administrative cost for the specification and implementation of the software interventions.
- According to the information currently available, a comparable method is based on the idea of replacing only the store instructions (write access to a control unit variable) via jump instructions to a subfunction. However, in microcontrollers having a mixed instruction set (16/32-bit CPU instructions), the store instructions may already be 16 bits because addressing is performed indirectly via address registers. These 16-bit instructions cannot be used to call a subfunction because a direct address-oriented call of a subfunction requires a 32-bit jump instruction. Therefore, the method according to the related art is usable only to a limited extent and may be used only with microprocessors having a strict 32-bit instruction set. In other words, when the store instruction has a fixed bit width, flexibility with regard to the function development is greatly restricted here. This is also true when a certain store instruction must not be manipulated at all for other reasons, so that populating in this way via a jump instruction to a subfunction is then not possible at all.
- In function development for control unit software as mentioned above, testing of software functions is performed on laboratory vehicles (measurement sites) or via appropriate software testing environments (module test). When performing tests on laboratory vehicles, the control unit inputs are stimulated from the outside by electric signals to thereby observe and measure the corresponding responses of the control unit and the software. In the case of the available software test environments for the module tests, only the software functions to be investigated are considered in a stand-alone operation within the test environment without taking into account feedback effects or cross-coupling with the system as a whole.
- The object of the present invention is to stimulate software functions in an integrated state within a software program in runtime and to test them and thus overcome the aforementioned problems in the related art.
- The present invention is directed to a device and a method for the stimulation of functions for controlling operating sequences, where the functions access at least one global variable of at least one program for control, at least one stimulation function which accesses the at least one global variable via at least one software breakpoint being advantageously provided.
- The functions are expediently stimulated within the program during the runtime of the program, in particular in real time within a runtime system.
- It is advantageous here that the global variable is assigned a first piece of data information and this first piece of data information is replaced by a second piece of data information corresponding to the new stimulation values.
- It is preferably within the scope of the present invention for the stimulation of functions to be accomplished by an internal bypass, with the software breakpoint being accomplished by assigning address information to the global variable, the address information being loaded from a memory means by a load instruction and the address information of the global variable of the load instruction being replaced.
- The address information of the global variable is advantageously replaced by the address information of a pointer variable, an initial address of the function being determined from the address information, and the functions for control of operating sequences being replaced by replacing the address information with additional functions.
- The software breakpoint may also expediently be accomplished by having the global variable addressed by a store instruction and the store instruction manipulated onto the global variable by replacing the store instruction with a jump instruction and replacing the functions for control of the operating sequences with additional functions by replacing the store instruction with the jump instruction.
- The present invention expediently uses “dynamic hooks” of software breakpoints without any changes in source code. The methods described for accomplishing this modify the address information of load instructions, modify the function calls and insert new program codes. These modifications are performed on an existing software program version, e.g., on the basis of targeted HEX code modifications.
- It is also advantageous that the address information of the global variable is replaced by the address information of a pointer variable, the address information of the pointer variable being in a reserved memory area, in particular of the memory means in the control unit.
- In addition to the modification with respect to the load instructions, in one embodiment a store instruction is advantageously manipulated onto the global variable by replacing the store instruction with a jump instruction. The functions for control of the operating sequences are expediently replaced and/or expanded by replacing the store instruction with the jump instruction through additional functions.
- According to the aforementioned device and method, the present invention describes a control unit containing such a device and makes it the object of the present invention along with a computer program suitable for execution of such a method. This computer program is executed on a computer, in particular an application control unit system according to the present invention or an application PC. The computer program according to the present invention may be stored on any machine-readable medium. Such a computer-readable data medium or machine-readable medium may be in particular a diskette, a CD-ROM, a DVD, a memory stick or any other portable memory medium. Likewise, memory media such as ROM, PROM, EPROM, EEPROM or flash memories and volatile RAM memories, etc., are also possible for storage. The choice of memory medium, i.e., the machine-readable medium, is thus not to be regarded as restrictive with respect to the computer program product as the object of the present invention.
- Using the present invention, the various rapid prototyping methods, software test methods and data calibration methods are rendered more rapidly usable and more flexible in handling. Thus the software breakpoints are used without tying up software development capacity. This results in a lower technical and administrative complexity on the whole and therefore reduces costs. At the same time, microprocessor types having a mixed instruction set of 16/32-bit CPU instructions, for example, may be supported.
- When activating the test sequences, the control unit function to be investigated is advantageously stimulated automatically by the integrated test software within the runtime system.
- The advantages of the object according to the present invention also include the fact that for the stimulation of the control unit function, no electric signals need be applied to the control unit from the outside. Another advantage is that the calculated output values of the stimulated control unit function are directly available again to the real time system. Thus, for example, complex control algorithms within the control unit may be investigated and tested in greater detail and developed further if necessary.
-
FIG. 1 shows a system or a device according to the present invention for adapting the functions. -
FIG. 2 illustrates the sequence for determining the breakpoints or software breakpoints in the program. -
FIG. 3 shows an overview and a selection of various methods for modification of the load instructions and/or the store instructions. -
FIG. 4 shows a program diagram for a first and preferred modification method of the load instruction. -
FIG. 5 illustrates a program diagram for a second modification method of the store instruction. -
FIG. 6 illustrates a program diagram for a third modification method of the store instruction. -
FIG. 7 illustrates a program diagram for a fourth modification method of the store instruction. -
FIG. 8 shows a schematic diagram for adjusting the calls of the functions for controlling the operating sequences. -
FIG. 9 shows the hook function for tying in the additional functions. -
FIG. 10 shows a schematic diagram of the memory segments in the memory means with regard to the hook function. -
FIG. 11 shows in greater detail a complete development process according to the present invention. -
FIG. 12 shows the internal bypass, in particular the procedure of dynamic linking. -
FIG. 13 illustrates a basic diagram for the stimulation of functions. -
FIG. 14 shows a flow chart for creating the test sequence software. -
FIG. 15 shows the development process according to the present invention. -
FIG. 1 shows a schematic diagram of an application arrangement having acontrol unit 100 and anapplication system 101, which are connected tointerfaces link 102. Thislink 102 may be designed to be wired or wireless. Amicroprocessor 105 is shown in particular having a mixed instruction set. Memory means 106 includes anaddress register 108, adata register 107 and a memory area for the at least one program to be adapted with regard to functions. The control means for implementing the present invention may be contained in the application system and/or represented by it or designed using the microprocessor itself. Likewise, memory means for implementation of the present invention may also be situated outside the control unit, in particular in the application system. The object according to the present invention is implementable using the device shown here. Although the functions may be adapted using an external bypass, the advantageous embodiment is to perform the adaptations internally in such a way that they are tied into the program run and therefore there are dynamic hooks for software interventions without any source code changes. - The object described here modifies the address information of load instructions, modifies the content of store instructions, modifies the address information of function calls and adds new program codes. These changes are implemented here in the exemplary embodiment on an existing software program version on the basis of specific hex code modifications.
- The various components with regard to the object “dynamic software breakpoint” according to the present invention being explained below are:
-
- Determination of the program points
- Modification of the program points including
- modification of the load/store instructions and
- modification of the function calls
- Creation of additional program code
- Tying in the software breakpoint code
- Segmenting the memory areas and
- Development process for creation of the program code
- Internal bypass
- Software test through the stimulation of functions.
- The method described below is based on the use of microcontrollers having a mixed instruction set, in particular 16/32-bit CPU instructions. For example, the TriCore TC17xx microcontroller (RISC/DSP/CPU) from Infineon is the example used here; it is a component of a control unit for controlling operating sequences, in particular in a motor vehicle, e.g., for engine control or for controlling the steering, transmission, brakes, etc.
- However, this method may also be used with microprocessors having a non-mixed instruction set, in particular in pure 32-bit microprocessors (RISC processors, e.g., PowerPC/MPC5xx).
- Essentially in this method it is assumed that the code generator of the compiler arranges the machine instructions sequentially. This is understood to refer to the sequential arrangement of instructions for loading address information of an indirectly addressed control unit variable, for example, into the corresponding address registers. In contrast, in the case of a directly addressed variable, the address information is in the instruction itself. This is the case with most compilers.
- Determination of the Program Points (
FIG. 2 ) - The starting point for this is a control unit software program which is available in the form of a hex code file, for example. Additional files may include a data description file (e.g., ASAP) and a linker file (e.g., ELF binary) which supply information about control unit variables and control unit functions.
- Using a disassembler software program (e.g., a Windows software program), the hex code file is disassembled. The corresponding addresses of the control unit variables to be bypassed are taken from the data description file or from a reference databank created for the method.
- The disassembler program created according to the present invention, e.g., a Windows software program, seeks the corresponding access instructions to the control unit variables (load/store instructions) in the disassembled program code with the assistance of the address information of these variables being sought, which affect the content of the variables.
- This disassembler program as a Windows software program is a simulation program which checks the register contents after each assembler instruction. If a store instruction is localized and the content of the loaded address register corresponds to the address value of the control unit being sought or if the memory destination of the store instruction corresponds to the variable address, then this is a source where the content of the control unit variables is modified.
- The manner in which the program code is modified at the source depends on the particular type of addressing of the control unit variables.
- This is depicted in
FIG. 2 , which shows controlunit program code 201 andsoftware function 202.Arrows 203 symbolize the method described here for determining the store instructions.Store instruction 204 of a variable access is shown in such a way that in the case of direct addressing, the memory destination of the store instruction is the RAM address, and in the case of indirect addressing, the content of the address register corresponds to the RAM address, so the load instructions may then be determined.Arrows 205 represent the method described here for determining the load instructions.Load instructions 206 are for loading the variable addresses, specifically the global variables. - Modification of the Program Points (FIGS. 3 Through 8)
- First, the load instruction sources and/or the store instruction sources are localized according to different types of addressing and then the control unit function in which the sources are located is determined for these sources, so that all the function calls in the entire program code may be accomplished through function calls of the newly created hook function(s), so that the original function call of the control unit function may take place within the corresponding hook function.
- Modification of the Load/Store Instructions
- With the microcontroller(s) described here, there are a number of different types of addressing in a wide variety of embodiments. It is possible to minimize this variety.
- Four methods which largely cover possible combinations of a write access to global variables are presented below. Other methods of code analysis are conceivable such as relative addressing via previously occupied address registers.
- To do so,
FIG. 3 shows an overview of the different methods for modifying the load and/or store instructions. Store instructions st.x here mean: st.b=store byte, st.h=store half word and st.w=store word. The four methods illustrated inFIG. 3 are explained in greater detail below. - Modification of the program points according to
method 1 is illustrated in greater detail inFIG. 4 .Method 1 involves, for example, a 16-bit store instruction and indirect addressing. Starting from the position of the found store instruction, the points are traced back in the disassembled program code until the particular load instructions are determined. The found load instructions are the deciding factor for this method. This method is used not only in problems with a mixed instruction set but also when for other reasons it is impossible to replace the store instruction with a jump instruction. - In
method 1 the determined load instructions, based on the subsequent store instruction, are replaced by address information of a pointer variable. This pointer variable is generated via a development environment, in particular the DHooks development environment. The address of the pointer variable is in a reserved free area of the memory means, the memory layout for variables. The modified load instructions address the same address register as the original instructions. The difference in the modified load instructions is in the type of addressing of the address register and the address information. -
FIG. 4 illustratesmethod 1 in a schematic diagram showingoriginal program code 401 and modifiedprogram code 411. The control unit function, function_a() here, is formed by 402, 406 and 417, 407. The instructions, i.e., instruction sequences, are shown in 402 and 417, respectively, and the actual functionality is shown in 406 and 407. This shows access axx% to an address register (e.g., a0 through a15 in the case of a 16-bit width) and access dxx% to a data register (e.g., d0 through d15 in the case of a 16-bit width). Let us now consider instructions movh.a and ld.a (load instructions) and st.x (store instruction) in 408, 409, 410, 413, 414 and 415. In this example, movh.a and ld.a are shown as 32-bit instructions (see 412 and 403). Store instruction st.x is shown as a 16-bit instruction (see 405) and therefore is not replaceable with a 32-bit jump instruction in this example. As stated previously, this also applies to all other cases in which such a replacement is impossible or undesirable. The novel instruction code according to the present invention, i.e.,program code 403, is now input into 412 and the load instructions are modified to pointer variable iB_PtrMsg_xxx (Ptr=pointer). The address of the control unit variable is replaced by the address of the pointer variable according to 404. The method of creating additional program code, i.e., additional functions, is explained in greater detail below according to the four methods. -
FIG. 5 shows in greater detail the modification of the program points according tomethod 2. The same notations and abbreviations as used inmethod 1 are also applicable here as well as in all other method examples.Original program code 501 and modifiedprogram code 511 are shown. The control unit function, function_a() here, is formed by 502, 506 and 517, 507. Instructions and/or instruction sequences are shown in 502 and 517, and the actual functionality is shown in 506 and 507. Access %axx to an address register (e.g., a0 through a15 in the case of a 16-bit width) and access %dxx to a data register (e.g., d0 through d15 in the case of a 16-bit width) are shown. Let us now consider instructions movh.a and ld.a (load instructions) and st.x (store instruction). Store instruction st.x is now shown as a 32-bit instruction (see 505) and is thus replaceable in this example by a 32-bit jump instruction jla. The novel instruction code according to the present invention, i.e., program code 503 (jla: jump instruction), is now input into 505. -
Method 2 is a 32-bit store instruction in conjunction with indirect addressing. The 32-bit store instruction is replaced by an absolutejump instruction jla 512 to a software balcony function (balcony_M2) (see call 520 of the software balcony function). With the jla jump instruction, the jump back address is stored in register a11 (see 521). - In
software balcony function 521 mentioned above, the content of address register %axx, by which the control unit variable is addressed, is replaced by the address value of a pointer variable (iB_PtrMsg_xxx). The index of address register %axx and of the previously loaded data register %dxx is identical insoftware balcony function 521. - When 32-bit store instructions are used for the software breakpoint, additional program code is required for this. This program code, generated in the DHooks development environment, is referred to as a balcony function. The balcony functions include additional initializing, copying and breakpoint mechanisms and are used as software functions to expand the breakpoint functionality. Balcony functions are used for
breakpoint methods - The content of data register %dxx which is used remains unchanged by jump instruction jla. Addressing is then performed via the pointer in the software balcony function and thus the store instruction is diverted to the pointer variable. Store instruction st.x writes data as in the original code.
- The sequence then jumps back into control unit function according to 522 via the jump back address stored in address register a11 via an indirect jump.
-
FIG. 6 shows in greater detail the modification of the program points according tomethod 3. The same notations and abbreviations are used here specifically as formethod 2 and for all other method examples.Original program code 601 and modifiedprogram code 611 are shown. The control unit function, function_a() here, is formed by 602, 607 and 617, 607. The instructions, i.e., instruction sequences, are shown in 602 and 617, respectively, and the actual functionality is shown in 606 and 607. A special st.x (store instruction), namely st.t, is considered. Store instruction st.t is now depicted as a 32-bit instruction (see 605) and thus is replaceable in this example by a 32-bit function call (call balcony_M3). The novel instruction code according to the present invention, i.e., program code 603 (call: function call), is now input into 605. - In method 3 a 32-bit store instruction st.t is used in combination with direct addressing 618 (store instruction having address 610). The 32-bit store instruction is replaced by a 32-bit function call (call balcony_M3, 603) of a software balcony function (balcony_M3, 621) (see 604).
Software balcony function 621 includes the query of a breakpoint and the store instruction in the original state. With an activated breakpoint, no store instruction is executed. This variable is thus uncoupled from the control unit function. To do so, call 620 forbalcony function 621 is carried out from 612. Jump back 622 to the control unit function takes place via the address of the control unit variable (adr. of ecu variable) 619. -
FIG. 7 shows the modification of the program points according tomethod 4 in more detail. As is the case with all other method examples, the same reference notations and abbreviations are used here, specifically the same as those used formethod 2.Original program code 701 and modifiedprogram code 711 are shown. The control unit function, function_a() here, is formed by 702, 706 and 717, 707. The instructions, i.e., instruction sequences, are shown in 702 and 717, respectively, and the actual functionality is shown in 706 and 707. Access %axx to an address register and access %dxx and/or %dyy to a data register are shown. Instructions mov, st.x (store instruction) call and jla shall now be considered as described above in the methods. Store instruction st.x is shown as a 32-bit instruction (see 705) and is thus replaceable in this example by a 32-bit jump instruction. The novel instruction code according to the present invention, i.e., program code 703 (jla: jump instruction), is now input into 705. -
Method 4 uses a 32-bit store instruction st.x (710) in combination with direct addressing (718). The 32-bit store instruction is replaced by a 32-bit jump instruction jla (jla balcony_M4 — a). The jump instruction points to software balcony function 1 (balcony_M4 — a(), 721) which is called with 720. Insoftware balcony function 1 721, the content of the previously loaded data register %dxx is stored temporarily in a temporary DHook variable (iB_TmpMsg_xxx). Another balcony function (balcony_M4_b(), 724) is called from 721 with 723 via a function “call.” This secondsoftware balcony function 2 contains the actual breakpoint as inmethod 3.Software balcony function 724 contains the query of the breakpoint. When the breakpoint is deactivated, the content of temporary variable iB_TmpMsg_xxx is written back into the control unit variable (see 725). When the breakpoint is active, there is no rewriting. The control unit variable is thus uncoupled from the control unit function. The jump back to the control unit function then takes place via/22. - Modification of Function Calls (
FIG. 8 ) - For the localized load/store sources, the control unit function in which the sources are located is determined. This is done using the Windows software program developed for this method; on the basis of the position of the load/store instructions and with the help of reference information, it determines the corresponding beginning and end addresses of the control unit function.
- Next, all function calls of the control unit function in the entire program code are replaced by function calls of the newly created hook function.
- The original function call of the control unit function is performed within the corresponding hook function.
- For reasons of simplicity,
FIG. 8 uses the same diagram as that in the previousFIGS. 2, 4 , 5, 6 and 7 to make this illustration of the modification comparable. Original controlunit program code 801 and modifiedprogram code 811 are shown. A task list task_list is used and a corresponding extra function or subfunction subfunction_x() is used. For the sake of simplicity, there is no longer an explicit differentiation between instruction sequence and actual functionality (seeFIGS. 3 through 7 ). Theprocedure 804 according toFIG. 2 is used to determine the function addresses and function calls. According to 805, the address of function_a is replaced by the address of hook_function_a. Accordingly, at 806 the function call of function_a is replaced by the call of hook_function_a. Finally, in 807, the indirect function call of function_a is replaced by a call of hook_function_a (as a 32-bit instruction here). The newly formed program code with the replacements is indicated by nP. - Method for Creating Additional Program Code (
FIG. 9 ) - For each control unit function in which there is a breakpoint, a hook function may thus be created and/or is created.
FIG. 9 shows a schematic diagram of such hook functions, hook_function_a() and hook_function_x(). Controlunit program code 901 andmemory area 902 for additional program code are shown. Actual hook functions 903 andpossible initialization 904 of any pointer variable needed are also shown.Program code 905 is for the software breakpoints, the configuration and tie-in of the rapid prototyping methods in particular. Finally, call 906 of original control unit function function_a() is shown. This is comparable for second hook function hook_function_x() but is not shown again for reasons of simplicity. - The hook function thus includes the breakpoint mechanism which controls access to a rapid prototyping method via application data. In addition, initialization of pointer variables and function call of the actual control unit function are performed in the hook function if necessary.
- Features of the hook functions are described below as a function of the breakpoint methods.
- Re
Breakpoint Methods 1 and 2: - Before a store instruction to a control unit variable addressed by a pointer may be described appropriately, the pointer variable must be addressed using a variable address. The pointer is initialized in the hook function. If the breakpoint access is not active, the pointer is initialized using the address of the control unit variable. If the breakpoint access is active, the pointer is initialized using the address of a temporary DHooks variable. At this point, write access is diverted to the temporary variable, e.g., in the case of indirect addressing of the control unit variable.
- Re
Breakpoint Methods 3 and 4: - These two methods involve direct addressing of a control unit variable. No pointers which must be initialized are used here. The hook function includes the mechanism for controlling the software breakpoint and the function call of the original control unit function.
- At this point, the balcony function when replaced by a jump instruction as already explained above should be mentioned briefly. This use was explained above in detail. If 32-bit store instructions are used for the software breakpoint, then additional program code is required for this purpose. This program code is generated in the DHooks development environment and is referred to as a balloon function. Balloon functions include additional initialization, copying and breakpoint mechanisms and are used as software functions to expand the breakpoint functionality. Balcony functions are used for
breakpoint methods - Segmenting the Memory Areas (
FIG. 10 ) - Dedicated memory areas of the memory means in memory layout S1 of the control unit software program are needed for the breakpoint method. According to
FIG. 10 , the method shows free areas for code (DHook code) S4, data (DHook data) S3 and RAM (DHook-RAM) S2. The breakpoint functions (additional program codes) are stored in the code area, and application variables by which the breakpoint mechanism is controlled are stored in the data area. The pointer variables and administrative RAM variables needed for the method are stored in the free area for RAM variables. - Development Process for Creating the Program Code (
FIG. 11 ) - The software breakpoint code is generated automatically via a development environment created for the method and is illustrated again in
FIG. 11 . The variables inpoint 8 may also be selected automatically according to specifiable criteria. - 1. Hex code file (includes the machine code, e.g., in Intel hex or Motorola S19 format)
- 2. Application data description file (includes, for example, addresses and conversion formulas for variables and parameters)
- 3. ELF binary file (linker output file having addresses of functions and variables)
- 4. Program for converting machine code into readable assembler instructions
- 5. Disassembled program code (used as input for the simulator)
- 6. Converter for Providing Program Information
- 7. Reference databank (used to resolve open references)
- 8. User creates selection of variables for breakpoints
- 9. Information about control unit variables to be bypassed
- 10. Program code simulator (reads all opcodes sequentially and checks the register contents)
- 11. Automatically generated source code (includes the program code for the software breakpoints, additional functions and information about the program code points to be modified)
- 12. Software development environment (controls all procedures for generating hex code and the application data)
- 13. Application data for controlling the breakpoints
- 14. Program code+breakpoint code+patch code
- 15. Hex/A2l merge procedure (dynamic hooks components are connected to the original program code)
- 16. Application data description file (includes the project application data and the breakpoint application data)
- 17. Program Version Having Software Breakpoints
Method for Tying in the Software Breakpoint Code - The software breakpoint code is tied in, by a hex-code merge run, for example In this action, the results (hex codes) of the development environment for the dynamic breakpoint method are copied into free areas of the original software program (hex code). The method has a structure similar to that of the internal control unit bypass in which hex code information from two separate software development runs is joined together.
- Internal Bypass (
FIG. 12 ) - Coupling of the bypass program which includes at least one bypass function is performed by dynamic linking to predetermined interfaces in the control program. In this way, it is possible to access data present in the electronic computer unit during the program sequence of the control program.
-
FIG. 12 illustrates the dynamic linking of the bypass functions. Afirst block 60 reflects the vector table available to the control program. This figure shows a first column (vector) 62 and a second column (channel) 64. Thefirst column 62 contains references on the basis of which a decision is made as to which bypass function is to be activated. Thesecond column 64 contains information about whether it is an internal or external bypass. - A
second block 66 gives a table of function pointers containing a number of bypass functions to be activated. - A
third block 68 represents bypass services. Afourth block 70 and afifth block 72 stand for activated bypass functions and asixth block 74 stands for the control program. - Potential intervention points for the bypass functions are provided in
control program 74. This is accomplished by activating a driver layer (bypass services). - Before checking
control program 74, the application system loads the bypass functions into the memory of the ECU. References to the bypass functions are then entered by the application system into table 66 of the function pointers. - During the check, i.e., during the sequence of
control program 74,bypass services 68 in the ECU decide on the basis of entries in vector table 60 which intervention is active, i.e., which bypass function must be activated and where the reference to the bypass function is stored, as indicated byarrows 76. - If a bypass function for a potential intervention point has been activated, it is retrieved via the reference (dynamic link), represented by
arrows 78.Bypass services 68 execute the two active bypass functions 70 and 72 (arrow 80). With activated bypass functions 70 and 72, certain selecteddata 82 incontrol program 74 is accessed, as indicated byarrows 84. - In data transmission to bypass
functions data 82 statically present in the ECU. - The bypass drivers receive a reference to the stimulatable data flow in the data transmission of the control program, i.e.,
user software 74. In this way the data consistency requirements may be met. - The calculations of the bypass and the intervention into the data flow take place at the point in time when the value is also being calculated in the basic software. Due to the application of these trigger mechanisms and the communication described above, there is no dead time in the signal flow of the bypass function.
- Software Test by Stimulation of Functions
- The present invention relates to a software test method with which test sequences are generated according to the user's specifications in a test environment by using the methods of dynamic hooks (automatic software breakpoint) and internal bypass (rapid prototyping method) and these test sequences are run within the control unit software. Using the dynamic hooks software breakpoint method, the input variables of the corresponding control unit functions are bypassed. The test description, i.e., the test sequence over time, is generated in a program writing language developed for the method within the development environment created for the method. The source code thereby generated, describing the test sequence, is translated via a compiler and linking procedure into a runnable software program for the target hardware (control unit). The test sequence code is integrated and executed according to the internal bypass method.
- Stimulation of Software Functions within a Runtime System (
FIG. 13 ) - In investigating a control unit function, the corresponding input quantities (RAM variables) of the software function are bypassed. The bypassed RAM variables are stimulated via the integrated test sequence program in the control unit software. Scheduling for the call of the test sequence code may be specified in the development environment. The bypassed RAM variables are accessed via references.
-
FIG. 13 schematically shows such a stimulation. A corresponding control unit function(s) 91 is(are) shown. Interface variables, i.e., input variables 92 (inp1, inp2, inp3) which are calculated in other functions, i.e., software functions, for example, and are available as global variables in the system, are also shown. Three of the software breakpoints 93 already mentioned that are expediently activated via the application system (in particular 101 inFIG. 1 ) are also shown. - Stimulation values 95 (inp1 s, inp2 s, inp3 s) and/or their data information are available from the test sequence software, i.e., stimulation functions 94, as a replacement within the context of the breakpoint for the interface variables, i.e.,
input variables 92, and are blended in on activation of the breakpoints. - Finally, the
control unit software 96 itself is shown. - Method for Creating Test Sequence Software (
FIG. 14 ) - The test sequence is specified in a test description language developed for the method. In this test sequence, the input variables of the control unit function are brought to defined states. Various combinations of stimuli values, ramps or curves may be specified. The behavior over time is controlled via corresponding software functions within the description language.
FIG. 14 shows an example of such a test sequence description. -
FIG. 15 Shows the Development Process as the Object of the Present Invention: - E1 identifies the control unit software. E2 shows the test function and information about the interface variables. This also includes the scope of testing and the interface information on the software function or function to be tested or stimulated. E3 shows the bypass selection, i.e., the selection of bypass variables, and thus the software extent of the bypass. The dynamic hooks method is localized in E4 as described previously. The program version having bypassed input variables of the software function to be tested or stimulated, i.e., the control unit program having the software breakpoints, is accommodated in E5.
- In E6 the test sequence script is created, i.e., processed; this is the test description of the test sequence using a script language. Code translatable from the test script(s), in particular C code, is created by converter, i.e., code generator, in E7. This generated code, i.e., the test sequence program code, is depicted in E8. Library functions in a library (LIB) for sequence control are shown in E9.
- E10 shows the software test development environment for program code creation, i.e., the hex codes and application data. E10 also includes the compiler/linker tool set so that finally the software for the test sequence in the control unit is generated in E10. A distinction is made here between E11, the application data (A2L) for controlling the test sequence and the accesses to variables, and E12, the program code and test sequence code, i.e., the actual test sequence software (HEX).
- The merge procedure (A2l-HEX merge procedure) takes place in E13 to generate the project software, having integrated software breakpoints, and the test sequence code.
- Finally, this results in the control unit program having the integrated software test sequence. E14 contains the application data description file having the project data, i.e., breakpoint data and the application data for the test sequence control. E15 also contains the finished program version having the software breakpoints and the test sequence code.
- It is thus possible according to the present invention through an integrated software test method and the corresponding device to test software functions, i.e., functions for control of operating sequences, in particular in a motor vehicle, within a control unit system during runtime by stimulation of their input variables via corresponding software interventions, i.e., software breakpoints under various operating points.
Claims (16)
1.-15. (canceled)
16. A method for stimulating functions for controlling operating sequences, the functions accessing at least one global variable of at least one program for control, the method comprising:
providing at least one stimulation function; and
accessing the at least one global variable via at least one software breakpoint.
17. The method as recited in claim 16 , wherein the functions are stimulated within the at least one program during a runtime of the at least one program.
18. The method as recited in claim 16 , wherein the functions are stimulated in real time within a runtime system.
19. The method as recited in claim 16 , further comprising:
assigning the at least one global variable a first piece of data information;
replacing the first piece of data information by a second piece of data information corresponding to new stimulation values.
20. The method as recited in claim 16 , further comprising:
stimulating the functions by an internal bypass.
21. The method as recited in claim 16 , wherein:
the software breakpoint is accomplished by assigning address information to the at least one global variable,
the address information is loaded from a memory means by a load instruction, and
the address information of the at least one global variable of the load instruction is replaced.
22. The method as recited in claim 21 , further comprising:
replacing the address information of the at least one global variable by address information of a pointer variable.
23. The method as recited in claim 21 , further comprising:
determining an initial address of the at least one stimulation function from the address information.
24. The method as recited in claim 21 , further comprising:
replacing functions for control of operating sequences by replacing the address information by additional functions.
25. The method as recited in claim 16 , wherein:
the software breakpoint is accomplished by addressing the at least one global variable via a store instruction, and
the store instruction is manipulated onto the at least one global variable by replacing the store instruction by a jump instruction.
26. The method as recited in claim 25 , wherein the functions for controlling the operating sequences by replacing the store instruction by the jump instruction are replaced by additional functions.
27. A device for stimulating functions for controlling operating sequences, the functions accessing at least one global variable of at least one program for control, comprising:
a first stimulation arrangement for activating at least one stimulation function; and
a control arrangement for generating at least one software breakpoint, the at least one stimulation function accessing the at least one global variable via the software breakpoint.
28. A control unit, comprising:
a device for stimulating functions for control of operating sequences, the functions accessing at least one global variable of at least one program for control, the device including:
a first stimulation arrangement for activating at least one stimulation function, and
a control arrangement for generating at least one software breakpoint, the at least one stimulation function accessing the at least one global variable via the software breakpoint.
29. A computer program product for stimulating functions for controlling operating sequences, the functions accessing at least one global variable of at least one program for control, the product when executed resulting in a performance of:
providing at least one stimulation function; and
accessing the at least one global variable via at least one software breakpoint.
30. The computer program product as recited in claim 29 , wherein a code of the product is executed on a computer.
Applications Claiming Priority (3)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
DE10352172.0 | 2003-11-05 | ||
DE10352172A DE10352172A1 (en) | 2003-11-05 | 2003-11-05 | Method and device for adapting functions for controlling operating procedures |
PCT/DE2004/002462 WO2005045538A1 (en) | 2003-11-05 | 2004-11-04 | Method and device for stimulating functions for controlling operational processes |
Publications (1)
Publication Number | Publication Date |
---|---|
US20070214451A1 true US20070214451A1 (en) | 2007-09-13 |
Family
ID=34559486
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US10/578,342 Expired - Fee Related US7593791B2 (en) | 2003-11-05 | 2004-11-04 | Method and device for adaptation of functions for controlling operating sequences |
US10/578,341 Abandoned US20070214451A1 (en) | 2003-11-05 | 2004-11-04 | Method and Device for the Stimulation of Functions for Controlling Operating Sequence |
Family Applications Before (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US10/578,342 Expired - Fee Related US7593791B2 (en) | 2003-11-05 | 2004-11-04 | Method and device for adaptation of functions for controlling operating sequences |
Country Status (7)
Country | Link |
---|---|
US (2) | US7593791B2 (en) |
EP (2) | EP1682950A1 (en) |
JP (2) | JP4520466B2 (en) |
CN (2) | CN100524109C (en) |
DE (3) | DE10352172A1 (en) |
RU (1) | RU2352972C2 (en) |
WO (2) | WO2005045538A1 (en) |
Cited By (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20080244317A1 (en) * | 2007-03-26 | 2008-10-02 | Fujitsu Limited | Program and apparatus for generating system test specifications |
US20080270996A1 (en) * | 2007-04-25 | 2008-10-30 | Samsung Electronics Co., Ltd. | Apparatus and method for automatically extracting interface of embedded software |
DE102020112331A1 (en) | 2020-05-07 | 2021-11-11 | Audi Aktiengesellschaft | Learning system for learning individual programming inputs |
Families Citing this family (11)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US9296966B2 (en) * | 2006-07-06 | 2016-03-29 | Fluor Technologies Corporation | Propane recovery methods and configurations |
US8166344B2 (en) | 2009-01-28 | 2012-04-24 | Dspace Digital Signal Processing And Control Engineering Gmbh | Method for controlling an operating mechanism and a manipulation unit |
US8171341B2 (en) | 2009-01-28 | 2012-05-01 | Dspace Digital Signal Processing And Control Engineering Gmbh | Method for controlling an operating mechanism and a manipulation unit |
US8074118B2 (en) | 2009-01-28 | 2011-12-06 | Dspace Digital Signal Processing And Control Engineering Gmbh | Method for influencing a control unit and manipulation unit |
CN101807157B (en) * | 2010-03-30 | 2012-08-29 | 南京恩瑞特实业有限公司 | Defensive programming method based on function access global variables |
CN102402480A (en) * | 2011-10-12 | 2012-04-04 | 吴华中 | Tool for debugging (testing) command line of circuit board firmware |
EP2759939B1 (en) | 2013-01-29 | 2016-06-08 | dSPACE digital signal processing and control engineering GmbH | Method for manipulating a memory operation of a control device program on a virtual or real storage device |
EP2881858B1 (en) * | 2013-12-09 | 2016-04-06 | dSPACE digital signal processing and control engineering GmbH | Method for modifying the software in the memory of an electronic control device |
DE102016114914A1 (en) * | 2015-11-19 | 2017-05-24 | Dspace Digital Signal Processing And Control Engineering Gmbh | Method for operating a control device and for external bypassing set up control device |
CN107688467B (en) * | 2016-12-23 | 2019-11-15 | 北京国睿中数科技股份有限公司 | The verification method of processor stochastic instruction multiplexing |
DE102019203251B3 (en) * | 2019-03-11 | 2020-06-18 | Volkswagen Aktiengesellschaft | Process and system for safe signal manipulation for testing integrated safety functionalities |
Citations (7)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4866665A (en) * | 1986-10-27 | 1989-09-12 | Burr-Brown Ltd. | Break points system in a software monitor where entry address of break point routing equals op code of call instruction |
US5557797A (en) * | 1993-02-25 | 1996-09-17 | Ricoh Company, Ltd. | Scheduling method for automatically developing hardware patterns for integrated circuits |
US20020073400A1 (en) * | 2000-07-26 | 2002-06-13 | Michael Beuten | Method for monitoring a program execution using a debug logic |
US20020162051A1 (en) * | 2001-04-25 | 2002-10-31 | Joe Bolding | Synchronous breakpoint system and method |
US20020198638A1 (en) * | 2001-06-08 | 2002-12-26 | Wolfgang Haag | Method and apparatus for monitoring the control of operational sequences in a vehicle |
US6715140B1 (en) * | 1999-11-18 | 2004-03-30 | Fujitsu Limited | Program trace method and apparatus, and storage medium |
US7441235B2 (en) * | 2003-02-28 | 2008-10-21 | Denso Corporation | Method, apparatus and program for testing control program |
Family Cites Families (14)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4530052A (en) * | 1982-10-14 | 1985-07-16 | Honeywell Information Systems Inc. | Apparatus and method for a data processing unit sharing a plurality of operating systems |
US5195183A (en) * | 1989-01-31 | 1993-03-16 | Norand Corporation | Data communication system with communicating and recharging docking apparatus for hand-held data terminal |
US5109504A (en) * | 1989-12-29 | 1992-04-28 | Texas Instruments Incorporated | Graphics program adaptor |
JP2922723B2 (en) * | 1992-06-29 | 1999-07-26 | キヤノン株式会社 | Information processing device |
FI102220B1 (en) | 1995-10-30 | 1998-10-30 | Nokia Telecommunications Oy | Collection of failure information as part of a computer unit restart |
JPH09311792A (en) * | 1996-05-22 | 1997-12-02 | Hitachi Ltd | Register allocation method |
US6216237B1 (en) * | 1998-06-19 | 2001-04-10 | Lucent Technologies Inc. | Distributed indirect software instrumentation |
US6543049B1 (en) * | 1999-09-03 | 2003-04-01 | International Business Machines Corporation | Ranked break points and method for debugging a computer program |
WO2001090887A1 (en) * | 2000-05-25 | 2001-11-29 | Fujitsu Limited | Method fir processing program for high-speed processing by using dynamically reconfigurable hardware and program for executing the processing method |
JP2002099425A (en) * | 2000-09-25 | 2002-04-05 | Hitachi Ltd | Conversion method of local variable for global variable |
DE10106504A1 (en) | 2001-02-13 | 2002-08-29 | Bosch Gmbh Robert | Method and device for emulating control and / or regulating functions of a control or regulating device |
JP3729251B2 (en) * | 2001-03-12 | 2005-12-21 | オムロン株式会社 | Controller and system |
DE10228610A1 (en) | 2001-06-27 | 2003-01-16 | Bosch Gmbh Robert | Method for testing of a control program running on a computer unit, especially an engine control unit, whereby a dynamic link is created between a bypass function and the control program so that computer data can be accessed |
DE10220611A1 (en) * | 2002-02-15 | 2003-08-28 | Brueninghaus Hydromatik Gmbh | rotary bearings |
-
2003
- 2003-11-05 DE DE10352172A patent/DE10352172A1/en not_active Withdrawn
-
2004
- 2004-11-04 EP EP04797412A patent/EP1682950A1/en not_active Ceased
- 2004-11-04 WO PCT/DE2004/002462 patent/WO2005045538A1/en active Application Filing
- 2004-11-04 DE DE112004002647T patent/DE112004002647D2/en not_active Expired - Fee Related
- 2004-11-04 EP EP04802677A patent/EP1682951A1/en not_active Ceased
- 2004-11-04 RU RU2005124163/09A patent/RU2352972C2/en not_active IP Right Cessation
- 2004-11-04 US US10/578,342 patent/US7593791B2/en not_active Expired - Fee Related
- 2004-11-04 JP JP2006537060A patent/JP4520466B2/en not_active Expired - Fee Related
- 2004-11-04 US US10/578,341 patent/US20070214451A1/en not_active Abandoned
- 2004-11-04 WO PCT/DE2004/002447 patent/WO2005045537A1/en active Application Filing
- 2004-11-04 JP JP2006537062A patent/JP2007510205A/en active Pending
- 2004-11-04 DE DE112004002631T patent/DE112004002631D2/en not_active Withdrawn - After Issue
- 2004-11-04 CN CNB2004800327766A patent/CN100524109C/en not_active Expired - Fee Related
- 2004-11-04 CN CNB2004800328222A patent/CN100458606C/en not_active Expired - Fee Related
Patent Citations (7)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4866665A (en) * | 1986-10-27 | 1989-09-12 | Burr-Brown Ltd. | Break points system in a software monitor where entry address of break point routing equals op code of call instruction |
US5557797A (en) * | 1993-02-25 | 1996-09-17 | Ricoh Company, Ltd. | Scheduling method for automatically developing hardware patterns for integrated circuits |
US6715140B1 (en) * | 1999-11-18 | 2004-03-30 | Fujitsu Limited | Program trace method and apparatus, and storage medium |
US20020073400A1 (en) * | 2000-07-26 | 2002-06-13 | Michael Beuten | Method for monitoring a program execution using a debug logic |
US20020162051A1 (en) * | 2001-04-25 | 2002-10-31 | Joe Bolding | Synchronous breakpoint system and method |
US20020198638A1 (en) * | 2001-06-08 | 2002-12-26 | Wolfgang Haag | Method and apparatus for monitoring the control of operational sequences in a vehicle |
US7441235B2 (en) * | 2003-02-28 | 2008-10-21 | Denso Corporation | Method, apparatus and program for testing control program |
Cited By (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20080244317A1 (en) * | 2007-03-26 | 2008-10-02 | Fujitsu Limited | Program and apparatus for generating system test specifications |
US7949901B2 (en) * | 2007-03-26 | 2011-05-24 | Fujitsu Limited | Program and apparatus for generating system test specifications |
US20080270996A1 (en) * | 2007-04-25 | 2008-10-30 | Samsung Electronics Co., Ltd. | Apparatus and method for automatically extracting interface of embedded software |
US8255874B2 (en) * | 2007-04-25 | 2012-08-28 | Samsung Electronics Co., Ltd. | Apparatus and method for automatically extracting interface of embedded software |
DE102020112331A1 (en) | 2020-05-07 | 2021-11-11 | Audi Aktiengesellschaft | Learning system for learning individual programming inputs |
Also Published As
Publication number | Publication date |
---|---|
DE112004002647D2 (en) | 2006-09-21 |
CN1879067A (en) | 2006-12-13 |
EP1682951A1 (en) | 2006-07-26 |
JP2007511817A (en) | 2007-05-10 |
CN100458606C (en) | 2009-02-04 |
WO2005045537A1 (en) | 2005-05-19 |
WO2005045538A1 (en) | 2005-05-19 |
CN100524109C (en) | 2009-08-05 |
DE112004002631D2 (en) | 2006-09-21 |
US7593791B2 (en) | 2009-09-22 |
RU2005124163A (en) | 2007-03-27 |
CN1879066A (en) | 2006-12-13 |
US20070033583A1 (en) | 2007-02-08 |
JP2007510205A (en) | 2007-04-19 |
DE10352172A1 (en) | 2005-06-09 |
JP4520466B2 (en) | 2010-08-04 |
EP1682950A1 (en) | 2006-07-26 |
RU2352972C2 (en) | 2009-04-20 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US20070214451A1 (en) | Method and Device for the Stimulation of Functions for Controlling Operating Sequence | |
JP5495515B2 (en) | Test apparatus for testing at least one electronic control system and method for operating the test apparatus | |
JP4766540B2 (en) | Method and apparatus for performing verification of program code conversion | |
US7647583B2 (en) | Method and apparatus for emulating a hardware/software system using a computer | |
US9678867B2 (en) | Method for changing the software in the memory of an electronic control unit | |
JP7262818B2 (en) | Software environment for controlling engine debugging, testing, calibration and tuning | |
US10055363B2 (en) | Method for configuring an interface unit of a computer system | |
Hofer et al. | Toolchain-independent variant management with the Leviathan filesystem | |
JP2000010791A (en) | Method for initializing global register, computer program product, and device | |
US7975198B2 (en) | Test system and back annotation method | |
Beuche et al. | Managing flexibility: Modeling binding-times in simulink | |
Toeppe et al. | Automatic code generation requirements for production automotive powertrain applications | |
EP0388077A2 (en) | Method of optimizing the execution speed of an interpreted test language | |
Von Wissel et al. | Full Virtualization of Renault's Engine Management Software and Application to System Development | |
Jordan et al. | Virtual ECUs Used to Develop Renault’s Engine Management Software | |
US20030154322A1 (en) | Electronic system for developing software and a method for accessing the internal data of said software | |
Park et al. | Implementation of AUTOSAR I/O driver modules for a SSPS system | |
Beningo et al. | Writing Reusable Drivers | |
Gliwa et al. | General Basics | |
CN118226836A (en) | Controller variable reading and writing method and device, vehicle controller and medium | |
Roskos et al. | Toward user sharing of the microprogramming level under UNIX on the Perkin-Elmer 3220 | |
Correa et al. | Bypass rapid prototyping without ECU code changes | |
JP5208706B2 (en) | Code execution system, method and program | |
CN117435171A (en) | Integrated development method for RISC-V architecture processor | |
KR20100031808A (en) | Method for making and debuging program using virtual platform and appparatus therof |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: ROBERT BOSCH GMBH, GERMANY Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:WATZL, MARTIN;REEL/FRAME:018919/0371 Effective date: 20060614 |
|
STCB | Information on status: application discontinuation |
Free format text: ABANDONED -- FAILURE TO RESPOND TO AN OFFICE ACTION |