Software-defined vehicle integrating mechanical engineering, centralized computing, zonal architecture and automotive software
|

What Is a Software-Defined Vehicle—and Why Is It Changing Automotive Engineering?

For most of automotive history, engineers designed a car, manufactured it, sold it—and for the most part, that was the car.

Its engine output was fixed.

Its controls were fixed.

Its features were fixed.

Software-defined vehicle integrating mechanical engineering, centralized computing, zonal architecture and automotive software

Its electrical architecture was fixed.

Software existed, of course, but it was largely embedded inside individual vehicle systems.

The automobile left the factory as a mostly finished product.

The software-defined vehicle, or SDV, changes that idea.

In a software-defined vehicle, software increasingly determines what the vehicle can do, how its systems interact, and how those capabilities can evolve after production.

That sounds like a software story.

It is actually changing almost every part of automotive engineering.

A Software-Defined Vehicle Is Not Just a Car With Lots of Software

Modern vehicles have contained software for decades.

Engine controls.

Anti-lock brakes.

Airbags.

Transmission controllers.

Climate controls.

Infotainment.

None of those automatically makes a vehicle software-defined.

The more important shift is architectural.

In older vehicle architectures, software functions were frequently tied closely to specific electronic control units, or ECUs. A particular controller performed a particular set of jobs.

As electronic functionality expanded, automakers added more controllers.

That worked remarkably well for a long time.

But eventually the vehicle began accumulating a complicated collection of computers, networks, wiring and software that all had to communicate.

The software-defined vehicle attempts to reorganize that environment so software can operate more independently of individual hardware controllers.

Bosch describes the SDV as relying increasingly on centralized, cross-domain electrical/electronic architectures, while ETAS describes newer architectures as separating software from underlying hardware through operating systems, middleware and standardized interfaces.

This is not simply more software in the car.

It is a different relationship between the software and the car.

The Old Automobile Was Organized Around Hardware

Traditional automotive engineering organizations made enormous sense when the automobile itself was organized primarily around mechanical systems.

There were teams for:

  • Powertrain
  • Chassis
  • Body
  • Interior
  • Electrical systems
  • Manufacturing

As electronics expanded, additional organizations developed around systems such as:

  • Engine control
  • Infotainment
  • Safety electronics
  • Driver assistance
  • Battery control

Each subsystem could have its own controller and its own software.

The vehicle eventually became a federation of specialized systems.

But software does not necessarily respect those organizational boundaries.

Consider something like automated parking.

It might need information or control from:

  • Cameras
  • Ultrasonic sensors
  • Steering
  • Braking
  • Propulsion
  • Vehicle dynamics
  • Navigation
  • Driver displays

Whose system is it?

The answer increasingly becomes:

Everybody’s.

That is one of the fundamental reasons SDVs are changing automotive engineering.

Features increasingly cross the boundaries around which engineering organizations were originally built.

The Vehicle Is Becoming a Computing Platform

One architectural response is to move away from enormous numbers of narrowly focused controllers toward fewer, more powerful vehicle computers.

Bosch describes future E/E architectures built around powerful cross-domain vehicle computers combined with zone controllers distributed around the vehicle.

That does not mean every computer disappears except one enormous processor.

The vehicle will still contain distributed electronics.

Safety-critical functions may still require local processing.

Sensors and actuators still need interfaces close to the physical hardware.

But the direction is toward more centralized computing and less dependence on a dedicated ECU for every function.

This begins making the automobile look less like a collection of unrelated electronic boxes and more like a computing platform connected to physical machinery.

And that creates a major engineering change:

A new vehicle feature may increasingly be implemented in software without requiring an entirely new controller.

Zonal Architecture Helps Make This Possible

This is where zonal architecture enters the SDV story.

Traditional vehicle electronics are often organized primarily according to function.

Zonal architecture can organize physical connections according to where devices are located in the vehicle.

Sensors and actuators in one physical area connect to a nearby zone controller.

Those zone controllers communicate with centralized vehicle computers through high-speed networks.

ETAS describes this shift toward vehicle-centralized, zone-oriented architectures as an important part of the industry’s transition to software-defined vehicles.

That potentially reduces wiring complexity while also helping separate physical device connections from the software applications that use them.

Instead of saying:

This software belongs to this exact box.

The architecture can increasingly say:

This software needs this vehicle service or this data.

That sounds subtle.

Architecturally, it is enormous.

The Software Can Begin to Outlive the Hardware Design Cycle

Mechanical automotive development traditionally operates on long product cycles.

Design the component.

Prototype it.

Validate it.

Tool it.

Manufacture it.

Software development operates differently.

Software may change daily.

Weekly.

Monthly.

A software-defined vehicle therefore brings two very different engineering rhythms into direct contact.

The physical vehicle may take years to develop.

Its software may continue changing right up to production—and then continue changing afterward.

ETAS describes SDV development as requiring faster software delivery and continuous evolution so vehicles can remain current over time.

This creates a profound shift.

Start of production no longer necessarily means end of development.

For some vehicle functions, it may merely mean the beginning of another phase.

Over-the-Air Updates Change the Meaning of “Finished”

Over-the-air software updates are one of the most visible SDV capabilities.

They can potentially allow manufacturers to:

  • Correct software defects
  • Improve existing functionality
  • Update cybersecurity protections
  • Modify user interfaces
  • Improve energy-management algorithms
  • Add features
  • Change vehicle behavior

That means an automobile manufactured today may behave differently several years from now without having undergone a significant mechanical modification.

This is familiar in phones and computers.

It is much stranger when the product weighs several thousand pounds and travels at highway speed.

The engineering consequences are substantial.

Manufacturers must now think about the vehicle not only during development and manufacturing, but throughout its software lifecycle.

Software Development Starts Looking More Like Software Development

That sentence sounds ridiculous.

But historically automotive embedded software development has not always resembled modern cloud or application-software development.

Vehicle software has traditionally been constrained by long hardware programs, specialized ECUs and deeply embedded development processes.

SDVs are pushing automotive companies toward practices familiar in the wider software industry:

  • Continuous integration
  • Continuous testing
  • Automated builds
  • Version control
  • DevOps
  • Virtual development environments
  • Software reuse
  • Standardized APIs

But automotive companies cannot simply copy Silicon Valley development practices.

A streaming application can deploy a bug and fix it later.

A braking controller does not get that luxury.

So automotive engineering faces an unusual challenge:

Move at software speed while maintaining vehicle-grade safety.

That Makes Virtual Testing Far More Important

If software changes frequently, engineers cannot wait for a physical vehicle every time they want to test it.

This is why methods such as:

  • MIL — Model-in-the-Loop
  • SIL — Software-in-the-Loop
  • HIL — Hardware-in-the-Loop

become increasingly important.

Software can first be tested against models.

Then against virtual vehicle systems.

Then on actual controller hardware connected to simulated environments.

dSPACE specifically positions automated SIL and HIL testing, continuous integration and continuous testing as important parts of SDV development.

The principle is beautifully simple:

Find the problem before the problem becomes expensive.

And:

Introduce reality gradually.

In an SDV environment, that becomes not merely a smart testing philosophy.

It becomes a practical necessity.

The Digital Twin Becomes More Than a Presentation Graphic

Digital twins are another concept that becomes more meaningful in SDV development.

If engineers can create virtual representations of vehicle electronics, controllers and software, they can test enormous numbers of scenarios without waiting for physical hardware.

In one dSPACE case study involving General Motors, the stated goal is to create digital twins of vehicle electronic components so the electronic content can be simulated on computing infrastructure for activities such as regression testing.

That is a very different use of the digital twin from a flashy visualization rotating on a conference screen.

The twin becomes part of the engineering pipeline.

Software changes.

The virtual vehicle tests them.

Failures are identified.

Only then does the software move further toward physical validation.

SDVs Change What a Supplier Delivers

The automotive supplier relationship changes too.

Historically, a Tier 1 supplier might deliver a subsystem:

A brake controller.

A steering system.

A dashboard.

An ECU.

Increasingly, OEMs may need suppliers to provide components that can participate inside a broader software architecture.

That could mean supplying:

  • Software components
  • APIs
  • Virtual ECUs
  • Simulation models
  • Middleware compatibility
  • Cybersecurity support
  • Update capability
  • Test artifacts

AUTOSAR has explicitly positioned its standardized automotive software architecture as part of the industry’s emerging SDV ecosystem.

That means suppliers increasingly cannot think only about whether their component works.

They must also think about how their component behaves inside a software ecosystem they do not entirely control.

Mechanical Engineers Do Not Disappear

This is an important point because “software-defined” can easily sound like the physical car is becoming secondary.

It is not.

An SDV still needs excellent:

  • Structures
  • Suspension
  • Brakes
  • Steering
  • Thermal systems
  • Batteries
  • Motors
  • Seats
  • Crashworthiness
  • Aerodynamics
  • Manufacturing

Software cannot repeal physics.

If the tires cannot generate enough grip, software cannot magically create it.

If the battery overheats, code alone will not eliminate the thermal problem.

If a suspension component breaks, no OTA update repairs the metal.

The better way to think about SDVs is not that software replaces mechanical engineering.

Software increasingly coordinates, controls and changes the behavior of the physical engineering.

That makes integration between disciplines more important, not less.

Electrical Engineers May Feel the Change Even More

The SDV transition radically affects vehicle electrical/electronic architecture.

Automotive electrical engineers now have to think about:

  • High-speed Ethernet
  • Zone controllers
  • Centralized computing
  • Power distribution
  • Sensor networks
  • Network redundancy
  • Bandwidth
  • Latency
  • Cybersecurity
  • Hardware abstraction

The wiring harness itself can become part of the SDV strategy.

Bosch notes that centralized and zonal E/E architectures can reduce wiring and development complexity while enabling software updates and cross-domain functionality.

So something as seemingly mundane as where a wire travels through the vehicle can influence the flexibility of the future software architecture.

The physical and digital designs are becoming increasingly inseparable.

Software Engineers Now Have to Understand Vehicles

The integration runs the other way too.

A software engineer working on a consumer application may have little reason to understand structural dynamics, tire behavior or braking systems.

An automotive software engineer may need to.

Vehicle software operates inside a physical system governed by:

  • Momentum
  • Friction
  • Heat
  • Electrical limits
  • Sensor uncertainty
  • Mechanical tolerances

Software engineers cannot treat the vehicle as an abstract computer.

A command ultimately makes something physical happen.

That creates an engineering culture where mechanical, electrical and software teams need a much better understanding of one another.

Cybersecurity Becomes a Lifecycle Engineering Problem

If the vehicle can receive software remotely, it must also be protected remotely.

Connectivity creates opportunity.

It creates vulnerability too.

An SDV requires engineers to think about security across the entire vehicle lifecycle.

That includes:

  • Secure boot
  • Authentication
  • Encryption
  • Software signing
  • Network security
  • Intrusion detection
  • Vulnerability management
  • Secure updates

ETAS emphasizes that cybersecurity becomes a full-lifecycle requirement for software-defined vehicle computers and connected software architectures.

This has another interesting consequence.

A vehicle manufacturer may need to maintain software security years after the engineers who designed the original platform have moved to entirely different programs.

Software creates a very long engineering tail.

The SDV Changes Configuration Management

Software-defined vehicles also magnify an old engineering problem:

Which exact configuration are we talking about?

One vehicle model may now have:

  • Different hardware
  • Different software versions
  • Different regional configurations
  • Different activated features
  • Different sensor packages
  • Different calibration files
  • Different cybersecurity updates

Two physically identical vehicles may no longer be functionally identical.

Their software state may differ.

That means configuration management becomes even more important.

PLM traditionally helped engineers manage the definition of the physical product.

SDVs force organizations to connect that physical product definition much more tightly with the software definition.

The BOM is no longer enough.

The vehicle also has something increasingly resembling a software bill of materials and a constantly changing digital configuration.

Manufacturing Has to Know Which Software Belongs in Which Car

The problem reaches the factory too.

A finished vehicle may need:

  • Specific firmware
  • Specific software packages
  • Security credentials
  • Calibration
  • Configuration data
  • Feature activation

Manufacturing therefore becomes part of software deployment.

And once the vehicle leaves the plant, service organizations need to know exactly what software configuration is installed in it.

The traditional boundary between:

engineering

manufacturing

and

service

becomes increasingly porous.

Then the Business Model Starts Changing

Software-defined vehicles also allow automotive companies to contemplate something they historically struggled to do:

Continue selling functionality after the vehicle itself has been sold.

Potentially that can include:

  • Feature upgrades
  • Connected services
  • Performance enhancements
  • Driver-assistance capabilities
  • Temporary options
  • Subscriptions

Technically, this is fascinating.

Commercially, it can be attractive.

Consumers may have more complicated feelings.

There is an enormous difference between:

“We created a useful new feature three years after you bought your car.”

and

“The hardware is already installed, but you need to pay us every month to turn it on.”

Engineering enables both models.

Whether customers accept them is another question entirely.

Automotive Companies Are Becoming Software Companies—But Not Only Software Companies

You will often hear that automakers now need to become software companies.

There is truth in that.

But it is incomplete.

Automotive manufacturers need to become companies capable of building software at scale without forgetting that the software controls a physical machine.

That is harder than merely becoming a software company.

They need expertise in:

  • Mechanical engineering
  • Electrical engineering
  • Embedded software
  • Cloud software
  • Simulation
  • Systems engineering
  • Functional safety
  • Cybersecurity
  • Manufacturing
  • Data management

And all of those disciplines have to agree about what the vehicle is supposed to do.

This is fundamentally a systems-engineering problem.

The Biggest SDV Challenge May Not Be Writing the Code

The industry already knows how to write software.

The harder challenge may be integrating software created by:

  • Automakers
  • Tier 1 suppliers
  • Semiconductor companies
  • Operating-system developers
  • Middleware vendors
  • Cloud providers
  • Open-source communities

into one reliable vehicle.

AUTOSAR continues working on standardized automotive software architectures, while companies such as Bosch and ETAS emphasize hardware abstraction, middleware and standardized platforms as important ingredients for SDV development.

That suggests something important.

The competitive advantage may not simply belong to whoever writes the most software.

It may belong to whoever becomes best at managing software complexity.

Why Software-Defined Vehicles Are Changing Automotive Engineering

The transition affects nearly every engineering discipline.

Mechanical engineers must design physical systems that increasingly interact with software-controlled behavior.

Electrical engineers must create architectures capable of supporting centralized computing and enormous amounts of data.

Software engineers must develop code that meets automotive safety and reliability requirements.

Simulation engineers must build virtual environments capable of testing continually changing software.

Manufacturing engineers must manage vehicle software configurations at production.

Systems engineers have to make sure the entire thing still behaves like one coherent product.

And PLM and configuration-management teams must somehow maintain a trustworthy definition of a product that may continue changing after it has been delivered.

This is why SDV is more than another automotive acronym.

It changes what it means to finish designing a car.

The Automobile Is Becoming a Product That Is Never Entirely Finished

For roughly a century, automotive engineering had a reasonably clear endpoint.

At some point, the drawings were released.

The tooling was finished.

The vehicle entered production.

Engineering moved on to the next model.

Software-defined vehicles weaken that boundary.

The physical platform may be finished.

But the software may continue evolving.

New functionality can appear.

Old functionality can improve.

Security vulnerabilities can be patched.

Vehicle behavior can change.

That means automotive engineering begins extending further into the life of the product itself.

The automobile does not stop being a machine.

It becomes something stranger:

a machine whose engineering can continue after the machine has already been built.

And that may be the real reason the software-defined vehicle matters.

It is not merely changing the software inside the car.

It is changing when automotive engineering ends.

Similar Posts