Modern automotive ECUs are no longer single-purpose control units. Software defined vehicles (SDVs) integrate mixed-criticality workloads across multiple CPU cores, each characterized by complex task dependencies and communication patterns. Vehicle functions are distributed across SoCs that combine microcontroller and microprocessor architectures. The safetycritical software functions running on these platforms may exhibit either periodic or sporadic activation, depending on whether they process regular sensor inputs or must respond to asynchronous events.
Reserving exclusive hardware resources to handle sporadic events is not economically viable; instead, CPU resources must be shared with periodic applications and middleware components. A correct-by-design approach that ensures the timing behavior of both periodic and sporadic activities—along with their communication requirements—is essential for integrating and validating modern SDVs. This is where MotionWise provides a unique and unified solution.
Why Event-Driven Scheduling Matters in Modern Automotive ECUs
Traditional automotive systems were designed around periodic control loops: tasks executed at fixed rates, aligned with sensor sampling and actuator updates. This model works well for many safety-critical functions, but it does not cover the full spectrum of today’s vehicle software.
In modern ECUs and SDVs, we increasingly see:
- Asynchronous stimuli (network messages over Ethernet, sporadic sensor events)
- Dynamic interactions between software components across domains
- Asynchronous mode changes and system reconfiguration tasks (activation/deactivation of functions based on vehicle state)
Event-driven scheduling allows software components to react immediately to relevant events instead of waiting for the next periodic slot, while still respecting real-time constraints such as deadlines and bounded response times for a given event. At the same time, it improves the end-user experience by reducing perceived latency and increasing system responsiveness.
Without an explicit concept for scheduling sporadic tasks, system designers are forced to make compromises in system architecture and configuration:
- Waste CPU resources through oversampling, leading to unwanted application design changes and additional overhead due to frequent context switches
- Sacrifice predictable timing behavior– response times depend on the system state at the instant an event occurs and on the priority of the software components that need access to the CPU
- Sacrifice determinism – handling events with very high priority is a common workaround, but it can interfere with ongoing processing at arbitrary points in time, making execution order difficult to analyze and control
Neither is acceptable in safety and performance-critical automotive systems.
Use Case: Automatic Emergency Light Activation During Emergency Braking
A very tangible example of event-driven, real-time relevant execution in modern vehicles is the automatic activation of the hazard warning lights when an emergency braking maneuver is initiated by the vehicle itself.
During an emergency braking event the vehicle detects a critical deceleration condition
(e.g. based on vehicle dynamics or sensor fusion results). This condition is raised as an event within the vehicle system. It is not periodic, and its exact activation time is not known in advance. The event must trigger a control task that:
- evaluates the situation,
- decides whether emergency signaling is required, and
- initiates the emergency light blinker actuation.
This control task is event-driven by nature: it should execute as soon as the event occurs, but still within a bounded and analyzable response time. Furthermore, the faster the emergency light blinker is activated, the earlier following vehicles are warned, and the more time drivers or driver-assistance systems behind can react. Even small delays can have a measurable impact on rearend collision avoidance, especially at higher speeds or in dense traffic scenarios.
Architectural Implications in Modern Vehicles
In current SDV architectures the braking decision, the emergency event generation and the light actuation may all reside on different ECUs and communicate via Ethernetbased networks. Even though the emergency light activation task is triggered by asynchronous communication events, the execution must coexist with other tasks, such as time-triggered control tasks, dataflowdriven processing chains and background workloads.
The timing behavior must remain predictable and analyzable, even under load. This is precisely where explicit event-driven scheduling becomes essential.
MotionWise Schedule: Our Solution
MotionWise Schedule introduces event-driven scheduling as an integral part of its correct-by-design scheduling framework, fully integrated with existing real-time scheduling models.
Instead of treating sporadic tasks as an exception, MotionWise Schedule:
- models event-driven tasks explicitly,
- assigns them priorities, allocates to CPU cores
- integrates them into a globally optimized schedule
This ensures deterministic response times, predictable interference behavior, and efficient CPU utilization.
Figure 1: MotionWise Schedule workflow for adding sporadic tasks to the global schedule
Considering Sporadic Workloads at Design Time
The illustration contrasts unpredictable runtime demand with a planned and predictable resource supply.
Figure 2: Comparison of unpredictable runtime demand and a planned, predictable resource supply
On the left-hand side, the diagram illustrates the hardware resource demand of asynchronous events over varying time intervals. On the right-hand side, the available resource supply — here represented as CPU bandwidth — is shown as a blue line. The key point is that the supply curve is constructed such that it can always catch up with the accumulated demand within a bounded response time.
MotionWise Global Scheduler plans and allocates the CPU at design time, even though the exact event activations are not known. Instead of reacting ad hoc at runtime, sufficient processing capacity is reserved and distributed in advance, guaranteeing that sporadic, event-driven workloads can be handled in a predictable and analyzable manner, even when they share CPU cores with periodic applications.
Figure 3: This example shows the execution of the event-driven task and the scheduling relevant parameters
TimeTriggered and EventDriven: Not Either–Or
A key differentiator of MotionWise Schedule is that time-triggered and event-driven scheduling are not competing approaches.
Figure 4: MotionWise Schedule Tooling allocates event-driven workload with real-time guarantees on the same core as TT task
MotionWise Schedule combines both models:
- on the same ECU,
- on the same CPU cores, and
- within a single, analyzable scheduling framework.
This allows engineers to use the best execution model for each task, without fragmenting the system architecture.
Figure 5: Example of event-driven and periodic task execution on the same CPU core
Conclusion
The shift to integrated zonal and centralized architectures in SDV requires heterogeneous computation; there is no single “magic bullet” scheduling model for software-defined vehicles.
- Time-triggered scheduling for periodic hard-real-time deterministic control loops
- Dataflow execution for soft real-time data-driven processing
- Fixed-priority scheduling (rate-monotonic / deadline-monotonic) for safety-critical sporadic events
- Background scheduling for non-real-time workloads
MotionWise Schedule brings all of these models together in a unified framework—allowing customers to migrate tasks to the most suitable execution model without redesigning their system.
This is how MotionWise Schedule helps automotive software teams master complexity, preserve real-time guarantees, and future-proof their architectures.