Despite high hopes and anticipation, fully autonomous and self-driving cars are still a dream. For the last couple of years, players like Tesla, Waymo, BMW, Mercedes, Toyota, and others have been working towards making the autonomous driving dream a reality. Yet, none of them have launched a fully autonomous car to date. At present, all these global players are at different levels of maturity of Highly Automated Features. And despite having demonstrated prototypes of L3 and L4 Vehicles in multiple geographies, production dates are on a roll towards the future. However, it‘s not that the companies aren‘t invested enough, it‘s just that the key challenges lie in the complexities of transitioning these prototypes into production models.
The Complexities of Transitioning from Prototype to Production
The complexities involved in highly automated driving systems versus the complexities involved in any other electronic system are multifold as the former is also a safety application. Further, for electronic products in vehicles, the journey from prototype to production has standardized over decades whereas, for Autonomous Driving, the journey has just started with many new and unknown factors. Also, not to forget, software maturity is achieved only through rigorous verification and validation for production programs for any electronic system that goes inside a vehicle. This makes the unknown factors associated with Autonomous Driving even more daunting.
The complexities are extremely high with the above factors as each of these factors is being defined, refined and refactored for the first time through production programs. Also, it should be mentioned that most of the factors mentioned are going through the first-time journey of research to deployment in the real world.
1. Software Quality and Maturity
Achieving defect-free software quality is the minimum requirement of any production code. Usually, algorithms and features are developed to validate the concept at the prototype stage. Since every feature in autonomous driving is being developed for the first time, it is also critical to validate their feasibility during prototyping. Moving forward, once the concept and feasibility are achieved through prototype implementation; software refactoring activities are introduced to refine the code to be production-ready. Software quality is achieved through adherence to standard coding guidelines, assuring test coverage, adherence to formatting and naming conventions defined by the organization and through manual review of code compliance against design principles and architecture. Thus, making the refactoring process the most complex and time-consuming activity in the journey.
Further, the software maturity is determined by comparing the feature performance achieved from the actual in-vehicle test against the performance specified by the OEMs in their requirements. Further, adding to the complexity, the specification of software maturity is defined differently by different OEMs. Also, the definition of software maturity for customer functions is different for L3, L3+, and L4 features. Hence, a visible lack of a common definition of maturity and methodology to validate the maturity makes the process more complex during the production phase.
2. SW Integration, optimization, and performance on hardware
Autonomous Driving computing platform comprises of multiple multicore SOC (System On Chip) platforms. In an Automated Driving Hardware Platform, several specialized SOCs are used such as vision-specific SOC, Safety SOC, Multicore SOC, ASIC, and other SOCs. Each SOC is specialized in terms of software methodology to achieve the desired performance. The processing speed and memory utilization are the most critical factors for software-hardware integration. To achieve the desired performance on the computing platform, the code again goes through refactoring and optimization. This adds additional complexity and delay during the production phase.
3. Assurance of Dependability: Safety, Security, and SOTIF
Moving on to dependability: it is the key requirement for production readiness. Dependability includes Safety, Security, and SOTIF (Safety of the Intended Function). Usually, safety analysis is done in parallel to the prototype development. This is a technical constraint as logical architecture is the prerequisite to start the safety analysis. Further, safety activities are also done parallelly as the maturity of the system evolves during prototype implementation. Since these two activities run in parallel, the prototype software goes through changes due to recommendations from both safety and security. The recommendations can impose big changes at the design and the architecture level as well. The safety and security implementation, especially coverage of desired documentations and compliance with the process introduce further complexities and delays in the production phase.
4. Test Coverage through Requirement Driven verification
Unit testing and requirement driven verification and validation is key to ensure production-ready software quality. The coverage of these tests dictates software quality. Coverage is testing dependent on the coverage of requirements as well as the quality of requirements. In the autonomous driving prototype development phase, requirements are neither captured systematically nor in-depth. The complete focus is on the validation of the concept. Therefore, in this phase further complexities get introduced to develop requirements with the system engineering process and methodology through reverse engineering. Further, once the requirement coverage is achieved, test coverage is executed. These are additional activities and increase the complexity of the production programs further.
5. Virtual Simulation: Open-Loop and Closed-loop for sensors and features
More than 90% of the validation of sensors and features in autonomous driving is done through virtual simulation. Sensor Validation is performed using data-driven open-loop simulation which is also called reprocessing. Similarly, feature validation is conducted through data-driven closed-loop simulation virtually. These simulations comprise of several unknown and undefined methodologies which are still evolving. Further, simulation for large size data needs large investment and infrastructure set up. Also, yet another challenge in virtual simulation is to ensure the accuracy of validation through simulation. This demands sensor models, vehicle dynamic model and traffic models with higher fidelity.
6. Data-Driven Mileage Validation
In Autonomous Driving, validation coverage is derived through hundreds of millions of simulations runs. This is a regulatory requirement for a safety-driven system. Achieving millions of miles coverage needs high computational infrastructure, high-speed networks, large storage, and tools to facilitate simulation. This involves several ecosystem partners to come up with solutions. This also contributes to the increased complexity of the entire production program.
7. Infrastructure for data-driven development and validation: DevOps
As mentioned earlier one of the most critical factors of an Autonomous Driving production program is the infrastructure. Infrastructure is essential for both development and validation. Thus, the DevOps environments to ensure Continuous Integration (CI) is becoming critical for many production programs. This infrastructure requires an optimized architecture to bring the best utilization of both on-premises and cloud technologies with the latest storage and network infrastructure. This attracts large investments and becomes critical in the production journey.
8. Data Collection, Data management, and Data Engineering
Data-Driven validation through simulation is the only way to validate an autonomous driving system and software. Data collection across geographies is one of the critical activities being carried out at present. It is very expensive and requires high levels of accuracy. A range of engineering activities need to be carried out to structure and package the data to get the optimal outcome. Once data is collected, storage and data management play a pivotal role in providing the desired output for development and validation. A lot of technologies and methodologies are involved in this -Annotation, Hadoop ecosystem, Data management, etc. These opportunities are yet to be explored in depth by the automotive engineering community and hence adds a layer of complexity of dealing with unknowns.
KPIT as Leading System & Software Integrator brings agility and expertise to production programs
The automotive industry is undergoing a paradigm shift as OEMs are starting to develop software for autonomous driving in-house. With KPIT as an integrator, the autonomous system is developed through an ecosystem partnership. The illustration below shows a typical ecosystem partnership scenario at most of the OEMs with in-house Autonomous Driving programs.
As illustrated above, KPIT plays a key role as a system integrator in the ecosystem partnership. KPIT brings to the table the engineering services with scale and already developed software components to accelerate development. The service offerings such as software refactoring, unit testing, tools and methodology for software quality assurance, integrated verification and validation solutions through simulation, software integration, and embedded optimization provides the scale of expertise to reduce complexity and risk.
KPIT further brings years of experience in system engineering, safety, and security to bring end-to-end value to production programs starting from the concept till production. We are also the leaders in virtual simulation and big data. Several unique tools with higher levels of automation ensure huge virtual simulation and overall validation capacity. These tools ensure more than 30% improvement in productivity and improve speed and agility to complete validation by more than 40%. KPIT also brings partners to provide end to end validation solutions.
So, Self-Driving Cars- Too „Far“ in the „Near Future“?
Well, no doubts that the complexity of production programs remains high due to the ever-evolving technology and unknown factors associated with it. However, system & software integrators like KPIT bring specialized experience and expertise to make the journey less complex and bring speed to the development cycle thus, making self-driving cars, “Not” too “Far” in the “Near Future” after all.