Refine Your Search

Search Results

Author:
Viewing 1 to 11 of 11
Journal Article

On-Target Rapid Prototyping: A Practical Approach for Bootstrapping Production ECU Software Development

2011-09-13
2011-01-2267
Rapid control prototyping (RCP) is a widely used technique for verifying a controller's functional behavior. Typically, RCP uses a target processor with ample processing power and memory, which makes the technique attractive for engineers exploring new concepts. However, a large gap often exists between the RCP target and the production ECU in terms of the available code generation technology, the supporting tool chain, and I/O hardware. Consequently, significant work is required when migrating a controller from RCP to production. Furthermore, due to cost constraints, RCP systems are difficult to deploy in large numbers for fleet testing or preproduction trials. In response to the challenges associated with RCP, automotive engineers are moving towards a technique called on-target rapid prototyping (OTRP).
Technical Paper

Fixed-Point ECU Code Optimization and Verification with Model-Based Design

2009-04-20
2009-01-0269
When implementing production software for fixed-point engine control units (ECUs) it is important to consider the code optimization and code verification strategies for the embedded algorithms. System and software engineers work together to design algorithms that satisfy the system performance requirements without significant numerical quantization results. Software engineers and suppliers in mass production environments then implement the design on an embedded system with limited memory and execution speed resources. The primary goals after design are to generate optimized code and verify that the implementation matches the original model’s functional behavior. Model-Based Design simplifies fixed-point development by providing tools and workflows that support the complete design, implementation, and verification processes. System engineers performing on-target rapid prototyping for fixed-point ECUs benefit from automated scaling workflows that provide an initial fixed-point design.
Technical Paper

Verification, Validation, and Test with Model-Based Design

2008-10-07
2008-01-2709
Model-Based Design with automatic code generation has long been employed for rapid prototyping and is increasing being used for mass production deployment. With the focus on production usage, comes the need to implement a comprehensive V&V strategy involving models and resulting code. A main principal of Model-Based Design is that generated code should behave like the simulation model. It should also be possible to verify that the model or design was fully implemented in the code. As a result, the transformation of models into generated code must be done in a way that facilitates traceability between the model and code. Also automated tests should be performed to determine that the code executes properly in its final software and hardware environments. For example in a typical commercial vehicle application, the control algorithm and plant model are simulated together in a system simulation environment.
Technical Paper

Fixed-Point ECU Development with Model-Based Design

2008-04-14
2008-01-0744
When developing production software for fixed-point Engine Control Units (ECUs), it is important to consider the transition from floating-point to fixed-point algorithms. Systems engineers frequently design algorithms in floating-point math, usually double precision. This represents the ideal algorithm behavior without much concern for its final realization in production software and hardware. Software engineers and suppliers in mass production environments, however, are concerned with production realities and often need to convert these algorithms to fixed-point math for their integer-only hardware. A key task is to design scale factors that maximize code efficiency by minimizing the bytes used, while also minimizing quantization effects such that the fixed-point algorithms match the floating-point results within an acceptable numerical margin.
Technical Paper

Automatic Code Generation - Technology Adoption Lessons Learned from Commercial Vehicle Case Studies

2007-10-30
2007-01-4249
Using Model-Based Design, engineers model complex systems and simulate them on their desktop environment for analysis and design purposes. Model-Based Design supports a wide variety of C/C++ code generation applications that include stand-alone simulation, rapid control prototyping, hardware-in-the-loop testing, and production or embedded code deployment. Many of these code generation scenarios impose different requirements on the generated code. Stand-alone simulations usually need to run fast, for parameter sweep or Monte Carlo studies, but do not need to execute in true hard real-time. Hardware-in-the-loop tests by definition use engine control unit (ECU) component hardware that requires a hard real-time execution environment to protect the physical devices. Code generated for production ECUs must satisfy hard real-time, efficiency, legacy code, and other requirements involving verification and validation efforts.
Technical Paper

Safety-Critical Software Development Using Automatic Production Code Generation

2007-04-16
2007-01-1493
When developing software it is important to consider process, methods, and tools. For safety-critical software, standards such as IEC 61508 are often used to impose additional constraints on the development process and require the production of verification evidence and other artifacts. These constraints and artifacts are needed whether or not the design and code were produced manually or via tool automation. This paper discusses the usage of Production Code Generation for safety-critical software development.
Technical Paper

A Seamless Implementation of Model-Based Design Applied to a New Fuel Control Feature for an Existing Engine ECU

2006-04-03
2006-01-0612
Bringing a new automotive electronic control unit (ECU) to market is a multi-phase process. Generally speaking, the phases are engineering analysis, rapid prototyping, software implementation, test and calibration. A variety of engineering staff and tools are used as the ECU progresses through the development process. However, the use of different tools may require non-value-added steps to translate data and results from one process phase to another. This lack of integration introduces the potential for errors, adds delay and costs to projects, and makes it difficult to trace the behavior of the final product back to the original requirements. Model-Based Design addresses many of the integration problems through use of executable specification models and automatic code generation. However, connecting the design effectively to the prototype vehicle provides additional integration challenges since it requires specialized hardware interfaces and target-specific software device drivers.
Technical Paper

Model Style Guidelines for Production Code Generation

2005-04-11
2005-01-1280
Modern electronic control units (ECUs) are increasingly being developed using Model-Based Design with production code generation. With this approach, systems and software engineers model and simulate algorithms using block diagrams, state machines and data dictionaries. Code is then automatically generated from these models and placed into rapid prototyping or production microprocessors. The model structure and code generation configuration options significantly impact the efficiency and clarity of the design and resulting code. While clarity and efficiency may not be much of an issue when performing initial rapid prototyping evaluations on high performance computers, it is a significant concern in formal software development processes targeting low-cost, low-performance mass production ECUs. This paper describes model style guidelines and the best practices for automatically designing and generating optimized fixed-point and floating-point code.
Technical Paper

Production Code Generation for Safety-Critical Systems

2004-03-08
2004-01-1780
Software developed for safety-critical systems needs to be of high integrity. Special precautions and development steps are needed for high-integrity software that are not required for other software, although many would argue that they should be. Examples include language subsets, Verification and Validation (V&V), inspections, requirements traceability, documentation, and structural test coverage. Production code generation supports these activities by providing a complete software engineering development environment using models to specify the software. The models can then be tested and stressed within boundaries of the modeling environment. The tests and results can then be reused and applied to the generated code. This paper describes high-integrity code development techniques and shows how they can be automated and applied at the model level, improving quality while shortening design cycles.
Technical Paper

A Software Engineering Framework for Electronic Engine Controllers

2000-03-06
2000-01-0267
The embedded software development process for electronic engine controls is undergoing rapid changes and advancements. A large number of software process improvement (SPI) initiatives have recently commenced, partly in response to emerging technologies involving code generation [1, 2, 3 and 4] and automated testing [5,6]. The ability to generate and test embedded code using computer automation is certainly a tremendous advancement and worthy of review by SPI teams. However, there are other important software engineering tasks that also need consideration including verification and validation, configuration management, and documentation. Powerful computer automated tools are available for nearly every one of these tasks. This makes it easy for SPI teams to get caught up in the excitement of a tool's individual capabilities, without paying attention to its impact on the process as a whole. A software engineering framework consists of a process with methods and tools.
Technical Paper

Software Life-Cycle Costs and Solutions

1999-09-14
1999-01-2845
Electronic control system manufactures within the off-highway industry are aggressively upgrading their embedded software development processes to include simulation, rapid prototyping, and Hardware-in-loop testing (HIL). However, software life cycle concerns are not always considered during process revolutions such as these, even though most project managers agree that the majority of software costs accrue during maintenance. This paper proposes the use of automated implementation and unit test tools to generate production code and unit test vectors from a graphical representation of the ECU model used during simulation and prototyping. These automated tools not only improve development time but, more importantly, save on maintenance and reuse costs. Another proposal is made herein regarding the use of a new rapid prototyping environment for more accurately accounting for production microcontroller constraints during control algorithm design.
X