EN 
DE MicroConsult offers services related to the topics that are discussed at ESE Kongress: Training, seminars, and coaching. to.
Benefit from the experience of our embedded software engineering specialists and get in touch with us. We'd be happy to advise you.
MicroConsult training & coaching topics
ESE Congress 2015 Contributions, Part 1 – Topics:
- Agility
- architecture
- Real-time
- implementation
- Internet of Things
- management
- Modeling
- Multicore
- Contributions to ESE 2015, Part 2
- Homepage ESE Contributions
Lecture series: Agility
You can't not plan.
How to plan correctly in agile projects
Markus Unterauer, Software Quality Lab GmbH (ESE Congress 2015)
Agile is often interpreted and practiced as "without planning" or "just going for it." In reality, the opposite is true. In agile projects, highly structured and careful planning takes place at multiple levels, from the product itself through releases and iterations to the tasks to be performed within each iteration. The foundations of this approach are rolling planning, which becomes increasingly detailed as implementation approaches, and the continuous adaptation of plans based on feedback from the iterations.
Embedded Clean Code
The software engineer as the center of industrial software development
Thomas Winz, softwareimotion (ESE Congress 2015)
Software is a valuable asset developed in an environment of great uncertainty. Without proper and sensible industrial software development, this tension makes any cost-benefit analysis impossible; this is precisely where eCc (embedded clean code) comes in.
How much agility can the certification tolerate?
Agile development methods for safety-critical software
Ingo Nickles, VectorSoftware, Martin Heininger, HEICON (ESE Congress 2015)
The Agile Manifesto addresses points in software development projects that many experienced project managers readily agree with. Agile methods originated in IT software development. At first glance, different aspects seem to take precedence in the development of safety-critical embedded systems/software. Are there ways to bridge these two worlds? To compare them, the underlying principles are analyzed, and appropriate conclusions are drawn.
Lecture series: Architecture
How do requirements become a software architecture?
Efficiently develop a verified product architecture
Peter Schedl, IBM Germany GmbH (ESE Congress 2015)
The industry-proven Harmony method for creating architectures for embedded products will be presented. The presentation will describe the interplay between requirements, functional architectures, and design. Particular emphasis will be placed on the importance of continuous verification of the development steps.
Designing and Maintaining a High-Performance Embedded Software Architecture
Erik Hons, National Instruments (ESE Congress 2015)
Well-designed software architectures enable better reuse of software components and more rapid development of system variants than monolithic designs. Software architectures are necessarily abstractions, and therefore have to be carefully designed to perform well. This case study follows the design of such an architecture for large distributed embedded control systems with lessons on delivering and maintaining system performance as architectures are ported to new platforms.
Model-based architecture development and simulation
Practical example of driver assistance with AMALTHEA and chronSIM
Thomas Jäger, Robert Bosch GmbH, Ingo Houben, Dr.-Ing. Ralf Münzenberger, INCHRON GmbH (ESE Congress 2015)
A model-based approach, where further process steps are derived from a single source, offers many advantages. The AMALTHEA system model serves as the starting point for designing a robust, dynamic system and software architecture, as well as generating source code and test cases. This article presents a workflow for simulating, analyzing, and optimizing an architecture based on an AMALTHEA system model, particularly in the event of errors.
Lecture series: Real time
How to Measure RTOS Performance
Colin Walls, Mentor Graphics, Newbury UK (ESE Congress 2015)
Desktop or laptop computers are extremely powerful and amazingly low cost. This means that developers of software for desktop systems assume that there is infinite CPU power, so they worry very little about the speed of their code. They also assume that indefinite amounts of memory are available, so they do not worry about code size either. Embedded systems are different. Typically, there is enough CPU power to do the job, but only just enough - there is no excess. Memory size is limited. It is not normally unreasonably small, but there is unlikely to be any possibility of adding more. Power consumption is usually an issue and the software – its size and efficiency – can have a significant bearing on the number of Watts burned by the embedded device. It is clear that, with an embedded system, it is vital that the RTOS has the smallest possible impact on memory footprint and makes very efficient use of the CPU.
Model-based approach for real-time requirements
Arne Noyer, Padma Iyenghar, Elke Pulvermüller, University of Osnabrück; Joachim Engelhardt, Jürgen Kreyßig, Ostfalia University of Applied Sciences; Jonas Diemer, Symtavision; Michael Uelschen, Osnabrück University of Applied Sciences (ESE Congress 2015)
In embedded software engineering, timing requirements are among the most important non-functional requirements. Therefore, specialized tools are needed to analyze and validate the timing behavior of a realized embedded software system. Regardless, model-based software development continues to gain importance in order to manage the increasing complexity of embedded software. The Unified Modeling Language (UML) and Matlab/Simulink, among others, have become established as modeling languages. It is also possible to define timing behavior for model elements. Furthermore, it remains advantageous to manage requirements in specialized requirements management tools. A workflow for integrating timing requirements from specification to validation is presented. This workflow bridges the gaps between the different design domains.
Compile-time programming
Rainer Grimm (ESE Congress 2015)
What do classic template metaprogramming, the functions of the type traits library, and constant expressions have in common? They are all executed at compile time. This combines higher performance with extended functionality. Higher performance because runtime calculations are shifted to compile time. Extended functionality because programming at compile time can modify the resulting C++ source code. But how does all this magic work?
Health Check for the Development of Real-Time Systems
What's wrong with the development process?
Ralf Münzenberger, INCHRON, Friedhelm Stappert, Nuremberg Institute of Technology (ESE Congress 2015)
Many software projects for embedded systems experience problems with budget or schedule overruns. Reasons include, for example, that important requirements are not considered early enough, leading to errors being detected too late, especially in the dynamic behavior of a system. Based on numerous development projects, a concise questionnaire was created (Real-Time Health Check) developed a framework that uncovers weaknesses in the design process. Based on this, recommendations can be derived on how to better manage the dynamic behavior of real-time systems. Typical problems include: incomplete specification of real-time requirements, insufficiently robust architectures, and incomplete consideration of the overall system in early design phases. Many experienced architects are well aware of the importance of these aspects. Nevertheless, it has been shown that timing errors are often discovered too late in the testing phase.
Dynamic Memory Allocation: Justifiably Taboo?
Avoiding Risks Using New Memory Management Strategies
Steven Graves, McObject LLC (ESE Congress 2015)
Developers of fault-tolerant embedded systems must identify and eliminate possible failure points. Dynamic memory allocation is one key concern. A sound approach contributes to predictable and robust systems, while inattention can lead to instability, slow and/or unpredictable performance or failure. This paper argues that dynamic allocation is acceptable only in non-critical portions of fault-tolerant embedded systems, and then only when the technique's risks can be successfully mitigated. Fault-tolerant systems should instead employ custom memory allocators that are more precisely suited to the application's specific allocation patterns. Custom memory managers presented in the paper include block, stack, bitmap and thread-local allocators. The solutions presented retain the power and flexibility of dynamic memory management while mitigating common risks such as fragmentation and memory leaks, and improving efficiency and performance.
Timing architecture patterns and anti-patterns
How can timing gaps be closed? A practical report
Karsten Schmidt, Audi Electronics Venture GmbH, Kai Richter, Symtavision GmbH (ESE Congress 2015)
New technologies like multicore and Ethernet offer significantly greater computing and communication capacities than previously known. The available resources in the control units and the network must also be distributed among the numerous sub-functions to be integrated and their associated software. A well-designed timing architecture makes a crucial contribution to efficient implementation.
Dynamic software architecture for embedded systems
Software dynamics firmly under control
Frank Slomka, Christian Hausner, Institute for Embedded Systems/Real-Time Systems, University of Ulm (ESE Congress 2015)
UML and its extensions SysML and MARTE are well-suited for describing the static architecture of software. However, the dynamics of the system pose a challenge within a holistic development process for embedded software. In particular, the dynamic interaction between the hardware, the memory model, the operating system, and the application software can only be inadequately structured and described. Based on a new development process, a UML-compatible description method is presented that takes into account the specific characteristics of the dynamic behavior of embedded software. Special attention is paid to the dynamics of the hardware/software interface.
Lecture series: Implementation
The Magic of Macros – Using a C Preprocessor as Code Generator?
Andras Gaspar, Dr. Laszli Gianone, Dr. Gábor Tevesz (ESE Congress 2015)
Developing software for embedded systems restricts the usage of possibilities trivially available in a PC environment. One field is the handling of consistent data structures, eg identifying all CAN messages and applying their attributes consistently. One way of managing this type of configuration constructions is to create PC based configurator applications that generate all required embedded code constructions. But there is another way to use the preprocessor for the same purpose.
Embedded Software as an Integrated Product
Start Development at the API
Giancarlo Parodi, Renesas Electronics Europe (ESE Congress 2015)
When selecting commercial software, it is expected that the supplier has qualified it, tested it according to commercial standards, and ensure compatibility with the target microcontroller platform. This presentation will introduce the concept of an integrated software package that includes a real-time operating system, optimized stacks, application software, drivers, and configuration packages for hardware platforms. All of these components have been developed, integrated, and tested according to the IEC/ISO/IEEE 12207 standard.
Middleware – the future for testing and automation?
Dipl.-Ing. Robert Schachner, RST Industrie Automation (ESE Congress 2015)
The topic of "Industry 4.0" is on everyone's lips as a future vision for the manufacturing industry. Although – or perhaps precisely because – the definitions remain vague and many companies try to establish their own "standards," it is all the more important to address the associated challenges now and to seek solutions.
Stack & Heap: Understanding and mastering the great unknowns of embedded software
Martin Gisbert, IAR Systems (ESE Congress 2015)
Stack and heap are often mentioned together because both are non-static storage devices. Another unfortunate similarity is their limited determinism during access and the risks associated with overflows. This article provides an overview of how the stack works and tips for proper sizing. Since the heap, unlike the obligatory stack, is used relatively infrequently in embedded systems, this discussion of dynamic storage will be briefer.
C++11/14 Multithreading
Overview, highlights and pitfalls
Karl Nieratschker, SKT Nieratschker (ESE Congress 2015)
Since the introduction of C++11, the C++ standard library has also offered support for developing multithreaded applications. This functionality has been further expanded in the latest standard, C++14. While using the C++ Multithread API simplifies the porting of such applications, it also means that developers are limited to the capabilities of the standard library if they want to benefit from its features. Therefore, not only when developing new applications, but also for existing applications that still rely on platform-specific multithreading solutions, the question arises whether it makes sense to use or migrate to this API. This presentation provides an overview of the capabilities of the C++ Multithread API and shows what needs to be considered when porting applications.
Reliable and secure device drivers
The system is only as secure as its weakest driver.
André Schmitz, Green Hills Software (ESE Congress 2015)
Since the introduction of C++11, the C++ standard library has also offered support for developing multithreaded applications. This functionality has been further expanded in the latest standard, C++14. While using the C++ Multithread API simplifies the porting of such applications, it also means that developers are limited to the capabilities of the standard library if they want to benefit from its features. Therefore, not only when developing new applications, but also for existing applications that still rely on platform-specific multithreading solutions, the question arises whether it makes sense to use or migrate to this API. This presentation provides an overview of the capabilities of the C++ Multithread API and shows what needs to be considered when porting applications.
Modular application development for Arm Cortex-M
Develop faster with software components
Johannes Bauer, Arm Germany (ESE Congress 2015)
Modern microcontrollers based on Arm Cortex-M are suitable for an ever-increasing range of applications due to their high computing power, versatile peripheral functions, and low power consumption. These complex applications require advanced software development methods to ensure high-quality products and short development times. Arm's approach to modular development utilizes standardized software components in the CMSIS pack format.
Who's afraid of the evil "++"?
Why C++ makes sense down to the driver level
Matthias Bauer, redlogix Software & System Engineering GmbH (ESE Congress 2015)
Some prejudices are incredibly persistent. For example, this one: C++ is unsuitable for extremely resource-poor systems. This is simply not true! On the contrary, using the right C++ language features offers invaluable advantages, especially for systems with extremely limited resources.
Easier and Safer Configuration of Source Code Libraries
GUI for easier configuration of software libraries
Oreste Bernardi, Infineon Technologies AG (ESE Congress 2015)
Increasingly complex libraries are being developed for microcontrollers to accommodate the rising performance levels of microcontroller peripherals and applications. The usual configuration methods using #defines and/or data structures can be time-consuming and result in configuration errors. A graphical user interface coupled with a configuration generator offers a number of advantages here. Besides the obvious readability and parameter description benefits, a GUI could check and validate user input in real time. Unfortunately, GUI programming know-how is beyond the usual sphere of competence of microcontroller developers and acquiring this knowledge could be time-consuming. This article explores a novel approach to creating a user interface and a code generator to support the configuration of source code libraries. This approach is suitable for developers who do not have GUI programming expertise as it implements a new UI execution model that simplifies development and debugging.
Hardware-level software development
How do I develop software with hardware in mind?
Christian Siemers, Clausthal University of Technology, Institute for Process and Production Engineering (ESE Congress 2015)
A topic like Low-level programming (In a high-level language) it shouldn't really exist at all, because a high-level language implies hardware.independence —and not a specific addressing of their peculiarities. Nevertheless, this topic is indispensable in practice for the following reasons: resource limitations (especially in embedded systems); cumbersome configuration of peripheral elements (this is primarily at the bit and byte level); extreme adaptation of the software to hardware conditions, e.g., with specialized hardware or missing hardware components; real-time programming with very tight processing times.
Basic UI/UX Guide
Fundamentals for UI developers
Jürgen Messerer, Patrick Labud, bbv Software Services AG (ESE Congress 2015)
In the age of smartphones and tablets, even in industrial settings, increasing emphasis is being placed on visually appealing and user-friendly interfaces. To ensure customer acceptance of the user interface (UI), several factors must be considered. But how can this be achieved without a UI/UX expert? This article demonstrates how to prevent user stumbling blocks and shows how to design an efficient and intuitive user interface.
How HMI solutions can be culturally adapted
Dr.-Ing. Peter Rössger, Founder, beyond HMI (ESE Congress 2015)
This paper discusses intercultural differences in the perception and evaluation of human-machine interfaces (HMIs). Cultural background significantly influences users' expectations of technological artifacts (Rößger & Rosendahl, 2002; Heimgärtner, 2010). Approaches, problem-solving strategies, information processing, and the association of colors, symbols, and icons differ markedly between cultures (Marcus et al., 2003; Honold, 2000). Rößger (2014) discusses this topic using the example of infotainment systems in vehicles.
Best practices for tool-supported embedded GUI development
Manuel Melic, TARA Systems GmbH (ESE Congress 2015)
The balancing act between low-end hardware and high-end requirements, and how to future-proof UI software despite short product launch times, presents embedded GUI developers with a considerable challenge, especially when they are implementing a visually appealing user interface for the first time. This article presents principles that are crucial for achieving an optimal user experience on embedded platforms: What needs to be considered when GUI development is to be cost-efficient yet flexible enough to quickly adapt to changing requirements? How can the UI application be designed to be extensible and scalable so that it can be used in subsequent product generations with new features and new hardware? The best practices presented in this article are based on over 20 years of professional experience in embedded GUI development.
Being pretty is not enough
Requirements specification for user interfaces
Johannes Bergsmann, Software Quality Lab (ESE Congress 2015)
In today's world, dominated by attractive smartphone apps, software that, while good, lacks a modern and appealing user interface (UI) hardly sells anymore. However, a pretty interface alone isn't enough to impress users in the long run. What should you consider when designing a UI? Which techniques and methods can you use to create user-friendly UIs? Where should UI design be positioned in the requirements process? Which specification techniques are helpful from the initial idea to the finished UI design? These questions will be addressed in the following article.
Lecture series: Internet of Things
Energy transition: New business models through IoT technology
Energy giant sells know-how instead of electricity
Christine Mitterbauer, MicroDoc GmbH (ESE Congress 2015)
The energy transition is revolutionizing traditional models of centralized energy generation. While energy suppliers were previously responsible for the production and distribution of electricity, new concepts such as solar and wind power offer the possibility of decentralized energy generation and grid feed-in. Modern battery technologies enable private households to store electrical energy, use it intelligently themselves, or feed it into the grid and sell it.
Securing the Internet of Things
Evolving Threats & Developing Countermeasures
Haydn Povey, Secure Thingz (ESE Congress 2015)
The current Internet of Things has been described by the critical infrastructure industry as a slow-motion train wreck, with potentially catastrophic consequences for any industry or individual that relies on it. As an industry it is therefore critical that we re-evaluate the importance of security in out products, where security needs to be integrated, the value of the services security can deliver, and the consequences of being compromised to our customers and our shareholders.
What is behind the Internet of Things?
Everything new, or just embedded business as usual?
Dipl.-Ing. Günter Oblitschnig, Applied Informatics Software Engineering (ESE Congress 2015)
The Internet of Things (IoT) is currently the hottest topic. But what exactly is it? Is it simply network-enabled embedded systems, or is there more to it? This article provides the most important basics, terminology, and technologies related to the Internet of Things and answers the following questions: How do "things" differ from ordinary embedded systems? Which new technologies are relevant to the Internet of Things? Besides embedded systems, what else is needed to implement the Internet of Things? What does a typical IoT system architecture look like? What about security? What new business models will become possible?
Interoperability from sensor to cloud
Introduction to the open data exchange standard OPC UA (scalable for embedded systems)
Günther Trautzl, Euros-Embedded (ESE Congress 2015)
We live in a highly dynamic world where complex technology remains in the background and simply has to function, but with the expectation of comprehensive and error-free communication. Today, anyone can exchange information of any kind (voice, music, images, videos, fitness data, etc.) with anyone else using stationary or mobile devices, instantly, from almost anywhere in the world, without technical knowledge, without interruptions, and at minimal cost.
What IoT means for embedded software development
An analysis of trends, opportunities and risks
Prof. Dr. Dr.-Ing. Matthias König, Bielefeld University of Applied Sciences, Minden Campus (ESE Congress 2015)
Software development for embedded systems encompasses a broad range of applications, with the Internet of Things (IoT) representing a relatively new category. In IoT applications, networking and communication with the "thing" play a crucial role; for example, users will demand web-based access or mobile applications. Current trends indicate that the use of SDKs with powerful APIs will increasingly influence IoT development, similar to the trend observed in smartphones. Furthermore, the next generation of developers will be shaped by the advantages of using often open SDKs and APIs with extensive documentation. This article provides an overview of current trends influencing IoT software development and highlights the resulting tension between current and future "ideal" developer competencies.
Project prototyping with IoT developer toolkit
How to proceed with IoT development?
Klaus-Dieter Walter, SSV Software Systems GmbH (ESE Congress 2015)
What exactly characterizes an IoT development project, and where do its functional priorities lie? What resources does embedded systems hardware require in an IoT application? How is this hardware connected to the cloud, and which protocols or APIs are used? Here are some fundamental considerations regarding the necessary building blocks that can be combined to form an IoT developer toolkit, reducing risks and development time.
Monitoring platforms in the IoT
Usage scenarios for the acquisition and evaluation of biosignals
Volkhard Klinger, FHDW Hannover, Embedded Systems Department (ESE Congress 2015)
Modular and mobile systems are essential for the medium- and long-term monitoring of biosignals. The realization of a modular platform system for acquiring and analyzing biosignals, and its integration with sensors and actuators based on the Internet of Things (IoT) principles, enables new application scenarios. This paper presents two application examples and illustrates the corresponding adaptations to the platform-based concept. The application-specific integration of additional devices or sensors expands the platform's scope and flexibility. When external IoT systems are used, requirements for these systems arise, which are summarized below. It becomes clear that the advantages of the platform approach can only be maintained if these constraints are met.
Lecture series: Management
Lead successful projects with brain-friendly leadership.
What we can learn from brain researchers for projects
Dorothée Putzier, Putzier Consulting (ESE Congress 2015)
Leading projects presents a unique challenge, as organizational structures are often less clear than in line management positions. Where clear power structures are lacking, motivation becomes all the more crucial. Here, the latest findings in brain research can help us better understand how people can be motivated and how successful leadership works.
Successful team structures for long-term projects
Practical experience from aviation
Christian Glatzel, Zodiac Cabin Controls GmbH (ESE Congress 2015)
This presentation will provide insights into interdisciplinary team structures that have proven successful when a project team collaborates over several years. The practical experience draws on development programs in the aerospace industry, including interactions with aircraft manufacturers such as Airbus, Boeing, and Bombardier. The aim is to clarify which potentially unexpected factors can either advance or derail a project.
Led to innovation
What does leadership have to do with innovation?
Andreas Pfeiffer, Ginzinger electronic systems (ESE Congress 2015)
Innovation is the central theme of every organization. "We need to become more innovative" is a common refrain. In a time of constant change, the relevant criterion for a company's strength is not its size, but its adaptability to changing conditions. Today, leaders face the choice of either reacting to change or actively shaping it.
Ready for digital transformation?
Learning from software development
Dr. Anja Mentrup, consultant Judith Andresen (ESE Congress 2015)
In software development, it has become clear that complex issues cannot be tackled with a comprehensive plan that is then implemented verbatim. We have learned to build software in such a way that new insights and changing requirements don't derail us. Complex IT projects are best mastered through an iterative, incremental, and learning approach. Organizations and potential organizational restructuring are also complex undertakings. Daily operations demand a flexible organizational culture. Communication, knowledge transfer, and the organic integration of IT into the organization are vital. This is complex! A comprehensive plan with a direct, one-to-one implementation simply won't work. Learning from software development means designing the restructuring iteratively, incrementally, and with continuous learning.
Lecture series: Modeling
Model Driven Software Engineering 2.0:
Manifesto for the successful application of the MDSE
Andreas Foltinek, IMACS GmbH (ESE Congress 2015)
Increasingly complex structures, functions, and the interplay of technical systems shape our everyday lives. The accompanying, ongoing shift of tasks from mechanical and electronic components to software is placing it ever more firmly in the spotlight of innovation, thereby increasing its importance and the associated costs. Unfortunately, this development is not always taken into account, and software—even at the management and leadership levels—is still often perceived as a necessary add-on. Furthermore, there is a general awareness of the ever-present and supposedly free availability of software updates, an understanding reinforced by users and consumers who now accept this as a given.
Does MBSE accelerate or slow down the development of 500 kW braking power?
MBSE in tightly budgeted projects
Thomas Rogalski, enders engineers (ESE Congress 2015)
The core of this article is a report on the use of model-based systems engineering (MBSE) in a completed customer project. The project's goal was the development and deployment of a braking vehicle with a braking power of 500 kilowatts. Right from the start, there was considerable debate about whether to use MBSE, what expectations should be placed on the model, and what form the methodology should and could take. These questions were particularly influenced by the tight project budget. It was therefore clear that the methodology had to be implemented as pragmatically and effectively as possible. This article discusses the early project phase, the implementation of MBSE, and provides a summary of the overall results.
Code generation – what you can (and can't) do with it
Variants, possibilities and limitations
Horatiu O. Pilsan, Robert Amann, FH Vorarlberg (ESE Congress 2015)
Code generation is an essential part of a model-based development process. This presentation provides key information about what to expect and what not to expect from code generation in embedded systems. Starting with the foundation—the (structural, process, or controller) model—the presentation examines the differences between various approaches (signal flow and control flow, time-based and event-based). The necessary runtime systems are analyzed, and their potential interactions within a complete system are considered.
Architectural review for models
Effectively prevent model erosion
Ingo Battis, Sennheiser electronic GmbH & Co. KG, Thomas Eisenbarth, Axivion GmbH (ESE Congress 2015)
The promises of UML modeling with subsequent code generation include significantly higher maintainability, error-free operation, and flexibility compared to manual coding. In this scenario, the UML model, as an implementation model, takes over tasks from the coding process. Therefore, the UML model must be treated as if it were replacing code and protected accordingly from software erosion and implementation errors. An implementation must always follow an architecture, which consequently cannot be contained within the implementation model itself. Only then can the model be checked for various types of correctness.
Versioning: The challenge in modeling
Practical solutions for comparing and merging models
Dr. Konrad Wieland, LieberLieber Software (ESE Congress 2015)
The increasing complexity and ever-shorter release cycles of modern embedded software systems necessitate the parallel development of different versions. Adding to this challenge is the fact that these systems are developed by increasingly large and distributed teams. When using a model-driven approach, such teams must be able to work efficiently on parallel versions of a model. The advantages of version control systems have been successfully leveraged for years in source code generation. Their most important function is the comparison and merging of different versions. Traditional approaches use line-based and text-based applications for this purpose, which are insufficient for graphical models. This article demonstrates how models can be practically compared and merged to enable efficient version control.
Object-oriented and model-based tools
A workshop report
Dr. Andreas Wagener, Dr. Fritz Faulhaber GmbH & Co. KG, Robert Stemplinger, Markus Pauls, b1 Engineering Solutions GmbH (ESE Congress 2015)
Tools like Rhapsody allow code for embedded systems to be generated directly from the model. In the project under consideration, the entire system is designed and implemented in Rhapsody using this approach. Stacks and signal processing code are also integrated. This requires some preliminary work, increasing the level of abstraction for all involved – but with the added benefit of implementing a clearly recognizable architecture and thus a highly maintainable product.
Lecture series: Multicore
Automatic multi-core real-time validation
A process for model-based software development
Felix Martin, Andreas Sailer, Michael Deubzer, Timing-Architects Embedded Systems GmbH, Jürgen Mottok, Ostbayerische Technische Hochschule (ESE Congress 2015)
The trend toward using multi-core processors to meet the increasing performance demands of embedded real-time systems is clearly evident, as are the associated challenges regarding timing behavior, data dependencies, performance, and reliability. This paper presents a model-based approach, using the open-source real-time operating system Erika Enterprise as an example, to monitor compliance with safety-critical real-time requirements through tracing across the entire development process.
Efficient embedded multicore programming
Automatic parallelization of Scilab/MATLAB applications
Oliver Oey, Timo Stripf, emmtrix Technologies (ESE Congress 2015)
Due to ever-increasing performance demands, multi-core processors are being used in more and more areas instead of single-core processors. This shift has already taken place in the realm of desktop PCs and smartphones, but the transformation is still underway in the field of embedded systems. Parallel program execution can increase performance while simultaneously reducing power consumption. However, parallel programming has thus far been time-consuming and expensive, and requires specialized knowledge of the target systems. Within the ALMA-EU project, a consortium of research and industry partners has developed a toolchain that significantly simplifies parallel programming. Using automatic parallelization, sequential Scilab/MATLAB code is parallelized for embedded multi-core processors. This not only eliminates the need for time-consuming manual parallelization but also allows the code to be reused on different processors.
Security on all cores
Development of a safety architecture on the AURIX TC27x
Prof. Dr.-Ing. Peter Fromm, Thomas Barth, Darmstadt University of Applied Sciences, Mario Cupelli, HighTec EDV Systeme GmbH (ESE Congress 2015)
Multi-core controllers offer not only performance gains but also the possibility of implementing redundant applications on a single chip. However, since the physical coupling between the individual cores is significantly tighter than in discrete multi-controller solutions, special demands are placed on the software architecture, memory layout, operating system, and driver layer. This paper presents the challenges and approach involved in developing a safety architecture for forklift controllers using the Infineon AURIX TC27x multi-core chip and the PxROS operating system from HighTec. In particular, it describes the development of a safe and extensible base architecture, the design of a multi-core runtime environment, and the application of suitable design patterns for application development.
EMB² = Parallel + Heterogen
Parallel programming of systems-on-a-chip
Tobias Schüle, Siemens AG (ESE Congress 2015)
The Embedded Multicore Building Blocks (EMB²) are an open-source library for parallel programming of embedded systems. EMB² is based on MTAPI (Multicore Task Management API), a standard for task management in applications implemented with C/C++. Below, we provide an overview of EMB² and demonstrate how parallelism can be leveraged beyond the limitations of traditional multicore processors using MTAPI.
And the multicore is acting up again.
Tools and resources for multicore debugging
Jens Braunes, PLS Programmable Logic & Systems GmbH (ESE Congress 2015)
Debugging deeply embedded multicore systems is no longer just about tracking down incorrect variable values. Deadlocks, resource conflicts, and timing issues are now commonplace. This presents a significant challenge for developers, one that can only be overcome with appropriate support from on-chip debugging functions working in close conjunction with powerful software tools. This article introduces such solutions and demonstrates their capabilities as well as their limitations.
