Why the car is a distributed computer
3 min readA a small embedded computer that controls one vehicle function, built around a microcontroller with I/O, power and a bus transceiver (electronic control unit) is the basic building block. Each ECU is a microcontroller with a power supply, input/output pins, and a transceiver for one or more vehicle buses. A premium car can contain more than a hundred of them: one manages the engine, another the anti-lock brakes, another the airbags, another each door lock or window motor.
The overall plan of which ECUs exist, how they are connected, and where each function lives is the vehicle's the plan of a vehicle's electrical and electronic systems: which ECUs exist, how they connect, and where each function lives (electrical/electronic architecture). "E/E" separates this logical and wiring plan from the mechanical design: engine, chassis and electronics are designed together, and the E/E architecture is the electronics half of that joint design.
The first cars with electronics had one or two ECUs, and the natural way to add a function was to add an ECU. An ECU sits physically near its sensors and actuators because those need short, reliable wiring and a dedicated, real-time control loop. That is why the industry grew a distributed architecture: one function per ECU, placed where the function is.
The cost of that choice is wiring. Every ECU needs power, ground and bus connections, and every sensor and actuator needs a wire to its ECU. The result, the wiring harness, is the spine of the car and one of its heaviest, most expensive, and hardest-to-package parts. In a premium car it can weigh tens of kilograms and run to several kilometres of wire; the industry often calls it one of the three heaviest and most expensive components, alongside the engine and the chassis. Each new function adds not just an ECU but metres of wire and connectors, and every change to the harness ripples through the whole vehicle.
Engineers should care about E/E architecture because it is the skeleton on which all automotive software hangs. This module is about Adaptive AUTOSAR, the standard middleware for the modern central-compute car. None of that makes sense without first understanding why the industry moved from hundreds of small ECUs to a few central computers, because that move is exactly what forced the operating-system and isolation choices the rest of this module builds on. The rest of this lesson tells that story from the wire up.
How automotive E/E architecture evolved
4 min readThe first electronic controllers appeared in the late 1970s. Bosch's Motronic, introduced in 1979, combined digital ignition and fuel injection in one unit and set the pattern: a dedicated ECU for one function. Through the 1980s, anti-lock braking, airbags and body electronics each arrived as their own ECU, and the car became a small distributed system.
Communication came next. Bosch began developing the a multi-master serial bus, standardised as ISO 11898, that connects ECUs with small periodic frames bus in 1983, presented it at the SAE congress in 1986, and the Mercedes-Benz W140 became the first production car to use it in 1991. CAN gave ECUs a shared two-wire bus so they could exchange small periodic frames instead of point-to-point wires. Because CAN was not cheap enough for a window motor or a seat switch, the a cheap single-wire master/slave sub-bus for simple devices such as window motors and switches consortium formed in the late 1990s and produced LIN 1.0 in 1999. For the most timing-critical chassis functions, the a deterministic, time-triggered bus running at 10 Mbit/s per channel, used for chassis and safety functions consortium (founded 2000) produced a time-triggered bus that first reached production in the BMW X5 in 2006.
In 2003 a group of carmakers and suppliers founded AUTOSAR (AUTomotive Open System ARchitecture) to standardise the software inside all those ECUs. The result, now called the Classic Platform, gave every ECU the same layered software structure and a "virtual functional bus" so a software component could communicate without knowing where its peer lived. Classic AUTOSAR remains the standard for the small, signal-based ECUs of the distributed and domain eras.
The two forces that created the modern architecture arrived in the 2010s. First, single-pair switched, point-to-point Ethernet using single twisted-pair physical layers such as 100BASE-T1, the backbone of modern architectures: the IEEE standardised 100BASE-T1 in 2015 and 1000BASE-T1 in 2016, giving the car a switched, high-bandwidth network cheap enough to carry the whole vehicle. Second, the realisation that infotainment and driver assistance needed far more compute than a microcontroller, and that their software needed a full operating system. BMW developed Scalable service-Oriented MiddlewarE over IP, an AUTOSAR-standard protocol for remote procedure calls and publish/subscribe over Ethernet around 2011 as a service-oriented protocol for that Ethernet backbone, AUTOSAR published the first Adaptive Platform release in March 2017, and Tesla's Model 3 (2017) showed how far consolidation could go. Since 2020 the industry has converged on the phrase "software-defined vehicle" as the goal: decouple software from hardware, ship updates over the air, and treat the car as a compute platform.
The distributed architecture: one ECU per function
4 min readIn the classic distributed architecture every function is a dedicated ECU with a fixed job. The engine ECU controls injection and ignition; the ABS/ESP ECU controls braking stability; the airbag ECU fires restraints; a body ECU manages locks, windows and lights; separate ECUs drive the instrument cluster and the radio. Each ECU samples its own sensors, runs its own control loop, and drives its own actuators.
These ECUs talk over three main bus families. CAN is a multi-master bus that lets every ECU transmit small frames (up to 8 bytes of payload in classical CAN) and lets every other ECU see them; speeds up to 1 Mbit/s are typical, and the newer CAN FD variant raises the data rate and payload (up to 64 bytes) during the data phase. LIN is a cheap single-wire master/slave bus at up to 20 kbit/s, used for window motors, seat adjustment, switches and small sensors. FlexRay runs at 10 Mbit/s per channel with a deterministic, time-triggered schedule, which is why chassis and x-by-wire systems (functions that replace a mechanical control link with an electrical one) used it; MOST, a fibre-optic bus, carried infotainment and is now fading in favour of Ethernet.
| Bus | Speed | Topology | Typical use |
|---|---|---|---|
| CAN | up to 1 Mbit/s (FD: higher, 64-byte frames) | multi-master bus | engine, body, chassis |
| LIN | up to 20 kbit/s | single-wire master/slave | window motors, switches |
| FlexRay | 10 Mbit/s per channel | time-triggered, dual channel | chassis, x-by-wire |
| Automotive Ethernet | 100 Mbit/s to 10 Gbit/s | switched point-to-point | backbone, ADAS, cockpit |
The buses do not all connect directly; a an ECU that forwards messages between two or more buses and is the single integration point between them sits between them and forwards messages, for example from the powertrain CAN onto the body CAN, and exposes the diagnostic OBD-II connector. The gateway is the single integration point of the vehicle: every signal that crosses a bus boundary goes through it, so its routing table is a map of the whole car's communication.
Communication in this architecture is signal-based and completely static. Each ECU periodically transmits fixed signals, such as a wheel speed or an engine temperature, in fixed frames with fixed identifiers, and the consumers know in advance which identifier carries which signal. The whole map is captured in a document called the communication matrix, in practice a DBC file or the AUTOSAR system description: every frame, signal, cycle time and scaling is defined before the first prototype. There is no discovery and no dynamic binding; adding a signal means editing the matrix and re-flashing every affected ECU.
This model worked while cars had a few dozen ECUs, but it scales poorly. Each new function is a new ECU plus wiring plus a place in the harness and the matrix. The wiring harness, already one of the heaviest and most expensive parts of the car, grows with every feature. Each ECU is a recurring cost: a microcontroller, a connector, a power supply, a board and a housing. Every model variant and option package multiplies the matrix, because the same ECU must behave differently in every market and trim. And because nothing is discovered at runtime and nothing is updateable over the air, fixing a bug or adding a feature means a workshop visit and a flash.
Going deeperWhy the wiring harness dominates cost and risk
The harness is expensive for reasons beyond the copper. It is assembled largely by hand or by dedicated robots, because thousands of wires must be routed, crimped and taped into a shape that fits one specific body. It is one of the first components installed in assembly, so a mistake found downstream is hard to rework, and it is heavily variant-dependent, since every engine, trim and option changes which wires exist. A wiring change late in a programme is disproportionately expensive because it touches drawings, connectors, tooling and the physical build. That is why architectures are judged so heavily on harness metres and connector count, and why the zonal architecture's main selling point is not bandwidth but fewer, shorter wires.
Domain architecture and the first consolidation
3 min readA domain controller is a more powerful ECU that takes over the coordination, and often the software, of several related functions. The distributed architecture's "one function per ECU" gives way to a "one domain per controller" layout. The conventional domains are:
- Powertrain: engine, transmission, electrification and thermal management.
- Body: locks, windows, seats, lighting and climate.
- Chassis: braking, steering and suspension.
- Infotainment and telematics: display, audio, navigation and connectivity.
- ADAS (advanced driver-assistance systems): radar, cameras, ultrasonic sensors and sensor fusion.
In a domain architecture each domain controller concentrates the higher-level logic of its domain, while the remaining small ECUs become smart sensors and actuators on the domain's local CAN or LIN sub-bus. The domain controllers then connect to each other through a central gateway, usually over a faster bus or early Ethernet.
What the move buys is real: fewer ECUs, less wiring, and functions that used to span several ECUs now running as software tasks inside one controller. It also means fewer separate suppliers per domain, easier diagnostics, and a natural first step toward updating software by domain rather than ECU by ECU. Several manufacturers moved to domain architectures through the 2010s.
What it does not buy is the end of the problems. Domains are still silos: a function that needs data from both the chassis and the ADAS domain must still go through the central gateway, with its latency and its static routing. Software is still tied to a specific ECU's hardware, because each domain controller is a bespoke box from a particular supplier. And the communication is still largely signal-based CAN, so the matrix problem persists inside and across domains. Domain architecture is consolidation by function, not by location or by platform, and the next two steps attack exactly those remaining costs.
Zonal architecture and the Ethernet backbone
3 min readWhere domain architecture groups by function, zonal groups by place. A zone controller is an ECU mounted in a region of the car, such as front-left or rear-right, that gathers every nearby sensor and actuator over short local CAN or LIN links and connects them to the rest of the car over the Ethernet backbone. The same zone controller may, in one unit, handle a headlight, a door lock, a window motor and a side radar: functions from four different domains, unified by the fact that they live in the same corner of the car.
The point is the harness. In a distributed or domain car, a wire from the front of the car to the rear crosses the whole vehicle; in a zonal car, each device only needs a wire to its nearby zone controller, and only the zone controllers need to reach the centre. That converts long, heavy, parallel wiring into short local runs plus a few backbone cables. The saving in weight, cost, connector count and assembly time is the primary economic argument for zonal architecture.
The backbone is the second half of the idea. Because every zone controller is a gateway, the backbone becomes a switched Automotive Ethernet network, and the car gains a real data network with addressing, routing and quality of service instead of a broadcast bus. A function is no longer a box: it becomes software that can run where the compute is, reading its sensors and writing its actuators through the zones. That decoupling of function from location is the conceptual bridge to central compute and the software-defined vehicle.
Tesla's Model 3, launched in 2017, is the most-cited example of this shift in production: it consolidated most vehicle functions into a central compute module and a small number of body controllers, cutting the ECU count sharply compared with a conventional car of the same class. Zonal architecture is not a single standard; different manufacturers split the car into different numbers of zones and keep different amounts of logic in the zones versus the centre.
The transition has a cost. Moving every legacy function onto Ethernet means adapting dozens of CAN-speaking ECUs, and that is where the signal-to-service mapping of a later section comes from. A zonal car also concentrates risk: one zone controller now carries many functions, so its power supply, redundancy and software quality become critical in a way a door-lock ECU's never were.
HPC consolidation and the central compute SoC
3 min readA a high-performance computer, a central compute node built on a multi-core SoC that consolidates cockpit, ADAS and body functions (high-performance computer, also called a central compute unit) is a powerful central node, essentially a server for the car, built on a multi-core system-on-chip. It consolidates the functions that used to live in separate domain controllers, above all the cockpit and infotainment system and the ADAS stack, and increasingly the body and vehicle functions too.
The driving force is the workload. Infotainment needs a full graphics stack and an operating system rich enough to run a browser, a navigation stack and an app store. ADAS and automated driving need to ingest multiple cameras, radar and lidar, run sensor fusion and neural networks, and do it with bounded latency. Neither fits on the small microcontrollers of the classic ECU; both want general-purpose CPU cores, a GPU or NPU (neural processing unit) for inference, and gigabytes of memory. Consolidating them onto one SoC shares those expensive resources instead of duplicating them.
The SoCs used here are heterogeneous. Alongside many general-purpose application cores, they carry real-time cores, often lockstep pairs of Arm Cortex-R cores (two cores running the same code and comparing results) to run safety-critical control with deterministic timing, plus accelerators such as a GPU, an NPU, a DSP, a video codec and an image signal processor. This is a different animal from the single-core microcontroller of a door ECU, and it changes the software model completely: the HPC runs not a bare-metal loop but a full operating system, often more than one, which is the subject of the next section.
In production, this is the direction the industry has moved. Volkswagen's ID. family uses central compute units known as ICAS; Mercedes is consolidating onto its MB.OS hardware; Tesla has long run central computers for the vehicle and separate ones for driver assistance. The silicon comes from companies such as NVIDIA (DRIVE), Qualcomm (Snapdragon Ride and Cockpit) and Mobileye, alongside NXP and Renesas. The exact partitioning, how much runs centrally versus in a zone or a smart sensor, is a product decision rather than a fixed recipe, and it is one of the main things this lesson's lab asks you to justify.
Consolidation concentrates failure modes too. When one box runs the cluster and the braking support, a single hardware failure can take down several functions at once, so HPC platforms are designed with redundant power supplies and redundant communication paths, and with the fail-safe versus fail-operational reasoning developed in a later section.
Signal-based versus service-oriented communication
4 min readSOME/IP is the protocol that carries service-oriented communication in the modern architecture. In the service-oriented model, a software component offers a service with methods (callable remotely, like a function call), events (published to subscribers), and fields (a value that can be read, written and subscribed to). Another component finds that service and uses it, without either side knowing where the other runs.
This is the opposite of the signal-based model. In signal-based communication the data is what matters: a producer broadcasts a raw signal on a fixed frame identifier and cycle, and any consumer that wants it knows the identifier in advance from the communication matrix. There is no concept of asking and no notion of a service; there are only shared signals. It is efficient, since a CAN frame carrying a handful of signals is tiny and fast, but completely static.
Service-oriented communication adds everything a dynamic system needs. SOME/IP carries a message header with a service ID and method ID that together identify the operation, a request ID pairing a request with its reply, and version fields; on top of it, SOME/IP-SD (service discovery) lets services announce themselves with an offer and lets clients search for them with a find and subscribe to their event groups over multicast, with a time-to-live so a dead service disappears. A client can start before its server, find it later, and rebind after a restart, none of which a signal matrix can express.
The two worlds must coexist for a long time, because hundreds of existing ECUs still speak CAN. The bridge is the gateway in each zone or domain controller. It performs signal-to-service mapping: it reads the CAN signals on one side and publishes or serves them as SOME/IP on the other. A wheel-speed signal that arrives as a raw CAN frame is translated into a structured event, say VehicleSpeed, that any service can subscribe to; a service request in the other direction is translated back into a CAN frame. The communication matrix remains the source of truth for the signal side, and the mapping is the contract that joins the old bus to the new network.
Ingest: the zone controller receives a CAN frame carrying the wheel-speed signal on a known identifier
Decode: it extracts and scales the raw signal using the communication matrix definition
Represent: the value becomes a structured field of a vehicle-speed service
Publish: SOME/IP-SD offers the service and pushes events to subscribed consumers
Reverse path: a service method call, for example to lock a door, is encoded back into a CAN or LIN frame
Forward: the frame is transmitted on the local bus to the actuator ECU
Going deeperSOME/IP and service discovery, at the level of the header
A SOME/IP message starts with a fixed header: a 32-bit message ID made of the service ID (bits 31 to 16) and the method or event ID (bits 15 to 0), a 32-bit length, a 32-bit request ID split into client ID and session ID, a protocol version byte, an interface version byte, a message type byte, and a return code byte. Message types distinguish requests, responses, errors and notifications, and the return code carries errors such as "unknown service" or "out of memory". Service discovery rides on top as specific message types, FindService, OfferService, Subscribe and SubscribeEventgroup, sent to a multicast group with a time-to-live in the header; an offered service that does not refresh its offer within that time is treated as gone. This is why SOME/IP scales to a dynamic, partially connected vehicle network where ECUs sleep, wake and rejoin, while a static signal matrix cannot.
Why central compute forces a POSIX OS and a hypervisor
4 min readA classic ECU runs bare metal or a tiny static RTOS: the AUTOSAR OS, derived from OSEK/VDX, a 1990s German-French standard for automotive real-time operating systems. It schedules tasks in a single address space with no memory protection, no file system and no processes. That model is perfect for one microcontroller doing one real-time job, and it cannot run the software of a central computer. A cockpit system needs processes, virtual memory, a file system, drivers, a graphics stack and a network stack, in short a general-purpose operating system with a POSIX interface.
The Adaptive AUTOSAR platform, which is the subject of this module, therefore specifies that its applications run on a POSIX operating system, with the PSE51 minimal real-time profile as the required baseline. PSE51 is the smallest POSIX profile: threads, mutexes, condition variables and real-time scheduling, but no file system and no process spawning. In practice the operating systems used are Linux, often with the PREEMPT_RT patches for bounded latency, and QNX, a commercial microkernel RTOS with a POSIX interface and a strong safety story. In the embedded-Linux world this is familiar territory: an automotive Linux is built with the same Yocto or Buildroot machinery as any other embedded Linux, and Automotive Grade Linux (AGL) is exactly such a distribution, aimed at the cockpit.
Why a hypervisor, then? Because one SoC must host software of very different criticality. ISO 26262 classifies each function's risk as an Automotive Safety Integrity Level, the ISO 26262 risk classification from A (lowest) to D (highest); QM means no safety requirement: ASIL A is the lowest, ASIL D the highest, and QM means quality managed, with no safety requirement. An HPC typically mixes QM infotainment with ASIL-B driver assistance and, often, ASIL-D vehicle-motion control on the same chip. Letting QM software sit directly beside ASIL-D software would be unacceptable: a bug or a resource storm in the infotainment stack could delay or corrupt the braking function. A software that partitions one SoC into isolated virtual machines so different safety levels can share the hardware safely partitions the SoC into isolated virtual machines, each with its own operating system and its own slice of CPU, memory and devices, so that no failure in one guest can reach another. That is the principle of freedom from interference, developed further in the next section.
The hypervisors used in production are type-1 (bare-metal) systems such as the QNX Hypervisor, SYSGO's PikeOS, OpenSynergy's COQOS and Green Hills INTEGRITY, which are certified for safety use; open alternatives such as Xen are also used, and Jailhouse demonstrates the static-partitioning approach of Linux alongside real-time cells. This is the same virtualization technology covered in module M11, and the next lesson of this module, "Classic vs Adaptive AUTOSAR; where Linux, POSIX (PSE51) and hypervisors fit", treats the operating-system and hypervisor question in full. Here the point is architectural: central compute is what made a POSIX OS and a hypervisor mandatory, and that is the load-bearing idea connecting this lesson to the rest of the module.
Mixed criticality, budgets, and the mistakes to avoid
5 min readMixed-criticality consolidation means one SoC runs ASIL-D control next to QM infotainment. The danger is interference: two software components sharing a chip can affect each other through every resource they hold in common. The interference channels are the CPU cores, the shared caches, the memory controller and its bandwidth, the on-chip interconnect, the I/O and DMA paths, and even the thermal budget, since one hot component raises the temperature of the whole die. Freedom from interference, a core ISO 26262 requirement, means demonstrating that no failure or misbehaviour in one partition can cause another partition to fail.
The standard defence is static partitioning. Assign each guest its own dedicated cores, carve out its own memory region, partition or colour the last-level cache so no guest can evict another's lines, give it its own I/O devices behind an IOMMU (I/O memory management unit, which confines DMA to the owning guest), and reserve memory-controller bandwidth. Then monitor the boundaries: a watchdog per partition, a health channel that the hypervisor supervises, and budget counters that trip before a guest can exceed its share.
Partitioning has a real price, and engineers routinely underestimate it. Dedicated cores sit idle when their guest is not busy; cache partitioning shrinks the effective cache for every guest and raises miss rates; fixed memory carve-outs waste RAM that another guest could use; reserved bandwidth caps peak performance. The cost of freedom from interference is silicon and power that no single function could justify on its own, and it is only worth paying because the alternative, certifying one giant mixed-criticality software stack, is worse.
Alongside isolation there is a budget problem. Compute must be budgeted per function, in DMIPS (a measure of integer CPU throughput) for control code and TOPS (trillions of operations per second) for neural-network inference, with headroom for the worst case. Power must be budgeted against the vehicle's supply and against heat: a sealed central unit in a hot car has a fixed thermal envelope, and it must throttle gracefully rather than shut down. Redundancy must be budgeted too. A fail-safe design stops safely on failure: the function degrades or disengages and warns the driver, which is acceptable while the human is the fallback. A fail-operational design must keep working after a failure, which is required when there is no human fallback, as in higher levels of automated driving; it needs duplicated compute, power and communication, and often diverse, independently developed channels, which roughly doubles the cost of the safety path.
The three architecture generations trade these costs differently:
| Criterion | Distributed | Domain | Zonal + HPC |
|---|---|---|---|
| Wiring | heaviest | lighter | lightest, short local runs plus backbone |
| Bandwidth | per-bus, low | higher in-domain | high backbone, switched |
| End-to-end latency | bus arbitration, variable | gateway hops | predictable, QoS-capable |
| Cost per node | many cheap ECUs | fewer, larger ECUs | few expensive compute nodes |
| Security perimeter | many small endpoints | fewer endpoints | few, well-defended gateways |
Common architecture mistakes
- Symptom: the ASIL-D guest misses deadlines only under infotainment load. Cause: shared cache or memory bandwidth, an interference channel that was never partitioned. Diagnose with per-guest performance counters and cache-miss traces; fix by partitioning cache and reserving bandwidth.
- Symptom: a zonal car still has a heavy harness. Cause: the team kept long point-to-point wiring and only renamed the boxes; zoning pays only when devices actually connect to the nearby zone. Diagnose from the wiring diagram; fix by re-homing each device to its zone.
- Symptom: an Ethernet backbone that works in the lab jitters in the car. Cause: treating switched Ethernet as if it were deterministic without time-sensitive networking (TSN) for the streams that need it. Diagnose with per-stream latency measurements; fix with TSN schedules and stream priorities.
- Symptom: a central unit throttles and drops features on a hot day. Cause: the thermal budget was sized for average rather than worst-case ambient and load. Diagnose by correlating frequency, power and temperature logs; fix by re-partitioning the workload or enlarging the thermal solution.
Going deeperThe price of partitioning, concretely
Partitioning is not a configuration flag; it is silicon you give away. Dedicated cores cannot be shared, so a guest that spikes cannot borrow a neighbour's idle core. Cache partitioning, by way-partitioning or page colouring, caps the lines a guest may fill, which lowers its effective cache and raises its miss rate and its memory traffic. Memory carve-outs fix addresses so a guest cannot grow into another, at the cost of stranding RAM. And a safety guest must be scheduled so nothing else can preempt or delay its critical tasks, which on shared hardware means reserving not just cores but interrupt routing, DMA channels and bus arbitration. The result is that a mixed-criticality SoC runs every guest worse than a dedicated chip of the same size would, which is exactly the trade the consolidation is making, and why the cost model is safety first and utilisation second.
The software-defined vehicle and the new supply chain
5 min readA software-defined vehicle, a car whose functions are implemented and updated as software packages decoupled from the hardware (software-defined vehicle) is a car whose functions are defined by software that can be changed independently of the hardware it runs on. Today, most of a car's behaviour is fixed when the ECU is manufactured and can only be changed in a workshop by re-flashing. In an SDV the hardware is a stable compute platform, and features are software packages that can be deployed, updated and removed over the air (OTA).
The decoupling is the point. On the architecture of the previous sections, zonal controllers and HPCs on an Ethernet backbone, a feature is no longer a box with wires but an application with a service interface. Hardware and software get separate life cycles: the same platform can ship for years while the software changes monthly. OTA updates are the delivery mechanism, and they are now regulated: UNECE regulations R156 (software update management) and R155 (cybersecurity) require a managed, traceable update process with integrity checks, rollback and security, which is why OTA is an engineering discipline and not a convenience.
The end state the industry describes is an app-store model: third-party developers build apps against a published vehicle API, an OEM reviews and signs them, and they run in a sandbox on the car, the way a phone app runs on a phone. For that to work there must be a stable abstraction between the application and the car: a vehicle abstraction layer and hardware abstraction layer that present the car's services, such as speed, climate, doors and cameras, through one interface that is identical across vehicle lines and hardware generations. That abstraction is precisely what Adaptive AUTOSAR's runtime (the ARA interfaces) and the OEM platforms built on it, such as Volkswagen's Cariad stack or Mercedes' MB.OS, are meant to provide: write the app once, run it on any vehicle with the platform. Without that layer, every app would be a per-model integration, and the app-store economics would not close.
This shift reorders the supply chain. Classically the tiers were clean: the OEM (the carmaker) integrates; the Tier-1, a supplier such as Bosch, Continental or Denso, delivers a complete system, an ECU with its software; the Tier-2 supplies chips and components. Software sat inside the Tier-1's box, and the OEM often did not even own it. In an SDV world the software becomes the product and the differentiator, so OEMs build software in house, Volkswagen founded Cariad, Mercedes builds MB.OS, and Tesla has always been a software company, while Tier-1s reposition as software suppliers and integration partners, and Tier-2 chipmakers such as NVIDIA and Qualcomm gain influence because the silicon defines the compute platform. A "Tier-0.5" has even appeared: suppliers that work so closely with an OEM that they are effectively co-developers. The practical consequence for an engineer is that the skills in this module, POSIX, C++, service-oriented middleware and hypervisors, are now OEM- and platform-level skills, not hidden inside a supplier's black box.
Package: the app is built against the vehicle API and signed with the OEM's key
Stage: the OEM uploads the package to the update backend and targets a fleet or a set of vehicles
Download: the vehicle's update client downloads and verifies the package signature and integrity
Deploy: the app is installed into a sandbox and its services register with the runtime
Discover: other services and the HMI find the new service through service discovery
Monitor: the platform watches health, resources and telemetry of the new app
Rollback: if health checks fail, the update is reverted to the previous known-good version
An automotive app store is not the phone app store. Apps can touch safety-relevant vehicle services, so the OEM reviews, signs, sandboxes and monitors them, and the vehicle API exposes a deliberately limited, safe subset of the car. Safety, cybersecurity and liability shape the ecosystem far more than convenience does.
Try it
1 min readOpen the lab for this lesson and take the given function set, door locks, cameras and brake-by-wire, and map it onto domain, zonal and HPC architectures, justifying the gateway count, the bus types and the ASIL placement for each. Then sketch an SDV application end to end on paper: its service interface, how it registers and is discovered, the OTA path from a signed package to a running service, and the rollback trigger. Revisit the harness, bandwidth and security trade-off table for each of your three mappings and defend the cheapest design that still meets the safety goal. The practice pack has the templates and the step-by-step checklists for both exercises.
Key takeaways
- A modern car is a distributed computer: over a hundred small ECUs, one per function, joined by CAN, LIN and FlexRay.
- The wiring harness is the constraint: heavy, expensive and hard to package, it drove consolidation.
- Domain architecture groups functions into domain controllers; zonal groups them by location around an Ethernet backbone.
- HPC consolidation concentrates cockpit, ADAS and body functions on a few multi-core SoCs.
- Signal-based CAN is static; service-oriented SOME/IP adds discovery, methods, events and dynamic binding.
- Central compute needs a POSIX OS (Linux or QNX) and a hypervisor to separate QM from ASIL-D.
- Mixed criticality is bought with partitioning: dedicated cores, cache and memory come at a performance cost.
- The software-defined vehicle decouples software from hardware, ships OTA updates and reorders the supply chain.
Reflect
- Explain to a colleague, in two sentences: define ECU, E/E architecture, domain controller, zone controller and HPC and place each in a vehicle topology
- Which objective are you least sure about? Re-read that section, then do its exercise in the practice pack.
- What surprised you when you ran the commands yourself?
On a real board
Repeat the key commands on your Raspberry Pi or lab board over SSH or the serial console. Note anything that behaves differently from your PC, such as missing tools, a BusyBox shell or a read-only filesystem.
References and further reading
- Official docsAUTOSAR Classic Platform specifications
- Official docsCOVESA vsomeip, open-source SOME/IP implementation
- Official docsAutomotive Grade Linux
- Official docsOPEN Alliance SIG, Automotive Ethernet
- SpecificationIEEE 802.1 Time-Sensitive Networking task group
- ArticleCAN bus
Official documentation first. Links checked when the lesson was published.