Hardware vs. Software Reliability in MCU-Based Control Systems

Dear colleagues, when asking the seemingly simple question “What is more reliable — a hardware solution or a software one, when it comes to MCU-based control systems?” — it is nearly impossible to find a straightforward answer. The reason is that the nature of failures in software and hardware systems is fundamentally different.

1. Nature of Failures: Time and Degradation vs. Logic and Environment

For hardware components, the key reliability metric is MTTF (Mean Time To Failure) — the average time until a non-repairable element fails. IBM defines MTTF as the average operating time of a system or component before it ceases to meet specification [1]. A high MTTF indicates stability; a low one signals fragility.

The failure behavior of hardware is described by the classic “bathtub curve”: an early phase with elevated failure rates → a stable useful-life period with a constant failure intensity λ → a wear-out phase with increasing failure intensity. For MCU-based systems this means: a hardware failure is a matter of time and degradation. Every electronic component (capacitor, resistor, relay, semiconductor) has a finite service life, and its failure is a stochastic process with a corresponding probability distribution.

Software is a different story. Software does not physically degrade. Its failures are caused by logic violations, incorrect handling of boundary conditions, or unexpected runtime environment effects. At the same time, a software product can be tested to cover the relevant coverage metrics (statement, branch, MC/DC). Hardware failure, on the other hand, is always a matter of probability.

However, this principle does not give the full picture. For example, if signal filtering is implemented with a capacitor, it — like any other electronic component — is subject to degradation. These properties are systematized in Annex C of ISO 13849-1 [3].

2. What the Numbers Say: ISO 13849-1, Annex C

Annex C of EN ISO 13849-1:2015 provides methods for determining MTTF_D (Mean Time to Dangerous Failure) for individual components. Table C.1 contains typical B_10D and MTTF_D values for the main component categories:

Note: these are individual components. In a real system, they must be interconnected — by solder joints, PCB traces, and connectors. Each connection adds its own failure factor. The MTTF_D of a subsystem is computed through the series connection of the component chain, where overall reliability is determined by the weakest link.

For relays under rated load: B_10D = 400,000 cycles. At n_op = 365,000 cycles/year (1,000 actuations/day):

3. Reliability of Passive Components: Resistors, Capacitors

Now let us turn to the components typically used to implement “hardware” solutions: filters, voltage dividers, RC circuits. The SN 29500 standard (Siemens) is the primary source of reference FIT values for passive components and is widely used for reliability analysis per ISO 13849 and ISO 26262 [5].

Typical reference FIT values per SN 29500 for passive components (under reference conditions — 40°C, rated load):

At first glance, a metal film resistor with 0.2 FIT looks more reliable than a microcontroller with ~2 FIT. But that is a single component. A hardware solution for signal filtering, stabilization, or comparison requires a chain of components: several resistors, capacitors, an op-amp or comparator, possibly a relay or transistor. The total FIT of the chain is the sum of all individual component FITs.

Example: Analog RC Filter + Comparator vs. MCU

Consider a typical analog signal comparison circuit: 4 resistors (divider + feedback) + 2 capacitors (MLCC, filter) + 1 electrolytic capacitor (supply decoupling) + 1 operational amplifier:

Now let us compare this with an MCU.

4. MCU Reliability: Texas Instruments Data

Texas Instruments describes the FIT calculation methodology for semiconductors accounting for mission profiles in application report SPRABY3 [9]. Key data for the TMS320F28335 MCU:

Typical FIT for modern digital ICs ranges from 1 to 10 FIT @ 55°C, corresponding to an MTTF of 10⁸ to 10⁹ hours — i.e., from ~11,400 to ~114,000 years [10].

5. Summary Comparison: Discrete Components vs. MCU

Now let us consolidate all the data into a single table. This is the key comparison of the article:

The result is clear. An MCU at a typical mission profile (FIT ≈ 1.9) is approximately 18× more reliable than a simple analog circuit of 8 components (FIT ≈ 35). Even at worst-case 85°C, the MCU remains on par with — or even better than — the discrete component chain.

The software running inside the MCU “inherits” the chip’s reliability as its execution environment. But its own failures are not stochastic — they are deterministic: if the code is tested (statement, branch, MC/DC coverage) and contains no logic errors, it does not degrade over time. Unlike a capacitor, resistor, or relay.

One might assume that an MCU — being more complex than an individual capacitor — should be less reliable. But manufacturer documentation and standards show the opposite: the MTTF of a semiconductor is orders of magnitude higher than the typical values for discrete components. And in a real circuit with dozens of discrete components, the MCU’s advantage becomes even more dramatic.

6. Theoretical Foundation: The Laprie—Avizienis Taxonomy

The theoretical foundation changes everything. The theory of dependability and fault tolerance enables a systematic, architectural approach to this problem.

In the seminal work by Avizienis, Laprie, Randell, and Landwehr [11], as well as in the paper “Basic Concepts and Taxonomy of Dependable and Secure Computing” (IEEE TDSC, 2004) [12], the following is established:

Dependability is an integrative concept that unifies the attributes of reliability, availability, safety, integrity, and maintainability. The means for achieving dependability are classified as four orthogonal strategies:

The key conclusion from this taxonomy: neither the hardware nor the software approach alone is a silver bullet. A combination of solutions resolves everything. A reliable software-based control system implemented in an MCU can be made even more reliable by applying:

— hardware redundancy (dual-channel architecture, Category 3/4 per ISO 13849-1);
— a monitoring subsystem (watchdog timer, voltage supervisor);
— diagnostic coverage (DC_avg);
— measures against common cause failures (CCF per Annex F of the standard).

7. Conclusion

The numbers from ISO 13849-1, SN 29500, and semiconductor manufacturer data all point in the same direction: a software solution implemented in an MCU, when properly tested, is more reliable than an equivalent purely hardware solution based on discrete components.

The reasons:

— The MTTF of a microcontroller (~60,000 years at a typical mission profile) exceeds by orders of magnitude the MTTF of even the most reliable individual passive components. And a chain of a dozen components is weaker still.
— Discrete components must be interconnected — every solder joint, PCB trace, and connector adds to the total FIT.
— Software does not degrade. When properly tested, it operates correctly throughout the entire service life of the MCU.
— A software solution in an MCU can be reinforced with architectural measures (redundancy, monitoring), as formalized in functional safety standards.