Autonomous Driving and Driver Intelligence

Summary of Most Relevant Topic Papers

Quality assurance, especially of safety-related functions, is a highly important task. In the Carolo project [BR12b] [BR12], we built the car Caroline as a rigorous test infrastructure for intelligent, sensor-based functions through fully-automatic simulation (not only visualization) of the car within its surrounding: the city, pedestrians and especially other cars [BBR07]. Beside the simulation of a complete autonomous car with its sensors and actors, the simulation environment may also be used to test dedicated subsystems without any real hardware involved. By producing sensor input from the simulation and comparison of expected and actual behavior, subsystems may be automatically validated and thus developed in an agile way.

Driver Intelligence

From the viewpoint of software engineering, intelligent driver assistance and, in particular, autonomous driving is an interesting and demanding challenge, because it includes the development of complex software embedded within a distributed, life-critical system (car) and the connection of heterogeneous, autonomous mobile devices (other cars, infrastructure, etc.) into one, large, distributed system. Therefore, we are involved in a number of projects with major European car manufacturers in which we transfer modern software development techniques to the car domain. This transfer is necessary as, with its increasing complexity, software becomes a demanding driver of the overall systems’ development process and not just an add-on.

Caroline is a completely autonomous car, with which we participated in the Darpa Urban Challenge. There our car was driving autonomously in an urban area for hours. We successfully achieved the best place as newcomers (and best non-Americans). This resulted from a number of facts, including the rigorous application of agile development methods, such as XP and Scrum and a simulation for driving scenarios. In [BR12] we describe the process driven by story cards as a form of use cases, a continuously integrated and running software up to a rigorous test, and simulation infrastructure, called Hesperia.

In particular, we have developed a rigorous test infrastructure for intelligent, sensor-based functions through fully-automatic simulation (not only visualization!) of the car within its surrounding: the city, pedestrians and especially other cars [BBR07]. Our simulator is capable of running automatic back-to-back tests on the complete software system with no real hardware involved by producing sensor input from the simulation and acting according to the steering output of the autonomous driving software. Every night and, when necessary for every version change, the tests are automatically executed.

This technique allows us a dramatic speedup in development and evolution of autonomous car functionality, and thus, enables us to develop software in an agile way [BR12b]. We have successfully shown that agile development of high-quality software is possible and very effective in the automotive domain. However, it remains a challenge to combine this innovative, modern way of agile, iterative systems’ development with the current development standards, such as ISO 26262, in order to allow the OEMs to benefit both from efficiency and quality on one hand and legal issues on the other hand.

As tooling infrastructure, we mainly used an IDE such as Eclipse and in particular the SSElab storage, versioning and management services [HKR12]. Without those, agile development would not have been possible.

In [MMR10] we give an overview of the state-of-the-art in development and evolution on a more general level by considering any kind of critical system that relies on architectural descriptions.

In recent years, we also investigate in the next steps of autonomy, namely cooperatively interacting autonomous vehicles, allowing e.g., convoys with almost no distance to drive very energy efficient [FIK+18], as well as virtualization of development of safety algorithms.

With MontiSim, the Chair of Software Engineering developed a full blown autonomous and cooperative driving simulator [GKR+17]. It enables the developer to test driving software and identify errors and potentials in driving behavior. In large driving scenarios it can be beneficial to subdivide the simulation problem spatially as distant vehicles have no or only a low impact on each other [FIK+18] [KKRZ19]. Furthermore, to render the driving performance more realistic, the executing target hardware is emulated and the execution timings are estimated. The differences between the planned and the simulated trajectories with and without hardware emulation are depicted below.

Team CarOLO at the DARPA Urban Challenge

Agree to play YouTube video "Team CarOLO at the DARPA Urban Challenge"

Videos in this playlist:

  • one for each day in the Team CarOLO DARPA Urban Challenge 2007

Key Statements

  1. Automatic, repeatable tests speed up the development process.
  2. Testing of sensor-based functions works best by simulating the sensoric input on realistic scenarios.
  3. Intelligent driver assistance is tested best by simulating full urban scenarios, which is not that complicated.
  4. Software-intensive functions in embedded domains can be developed using agile methods.
  5. Hardware emulation is necessary in autonomous driving simulation to obtain precise driving results and enable an agile cross-platform development.

Selected Topic-Specific Publications

  1. [KKRZ19]
    J. C. Kirchhof, E. Kusmenko, B. Rumpe, H. Zhang:
    Simulation as a Service for Cooperative Vehicles.
    In: Proceedings of MODELS 2019. Workshop MASE, L. Burgueño, A. Pretschner, S. Voss, M. Chaudron, J. Kienzle, M. Völter, S. Gérard, M. Zahedi, E. Bousse, A. Rensink, F. Polack, G. Engels, G. Kappel (Eds.), pp. 28-37, IEEE, Sep. 2019.
  2. [FIK+18]
    C. Frohn, P. Ilov, S. Kriebel, E. Kusmenko, B. Rumpe, A. Ryndin:
    Distributed Simulation of Cooperatively Interacting Vehicles.
    In: International Conference on Intelligent Transportation Systems (ITSC’18), pp. 596-601, IEEE, 2018.
  3. [GKR+17]
    F. Grazioli, E. Kusmenko, A. Roth, B. Rumpe, M. von Wenckstern:
    Simulation Framework for Executing Component and Connector Models of Self-Driving Vehicles.
    In: Proceedings of MODELS 2017. Workshop EXE, CEUR 2019, Sep. 2017.
  4. [BR12b]
    C. Berger, B. Rumpe:
    Autonomous Driving - 5 Years after the Urban Challenge: The Anticipatory Vehicle as a Cyber-Physical System.
    In: Automotive Software Engineering Workshop (ASE’12), pp. 789-798, 2012.
  5. [HKR12]
    C. Herrmann, T. Kurpick, B. Rumpe:
    SSELab: A Plug-In-Based Framework for Web-Based Project Portals.
    In: Developing Tools as Plug-Ins Workshop (TOPI’12), pp. 61-66, IEEE, 2012.
  6. [BR12]
    C. Berger, B. Rumpe:
    Engineering Autonomous Driving Software.
    In: Experience from the DARPA Urban Challenge, C. Rouff, M. Hinchey (Eds.), pp. 243-271, Springer, Germany, 2012.
  7. [MMR10]
    T. Mens, J. Magee, B. Rumpe:
    Evolving Software Architecture Descriptions of Critical Systems.
    In: IEEE Computer Journal, Volume 43(5), pp. 42-48, IEEE, May 2010.
  8. [BBR07]
    C. Basarke, C. Berger, B. Rumpe:
    Software & Systems Engineering Process and Tools for the Development of Autonomous Driving Intelligence.
    In: Journal of Aerospace Computing, Information, and Communication (JACIC), Volume 4(12), pp. 1158-1174, 2007.

Youtube Videos of the Darpa Urban Challenge 2007