| Episodes | 371 |
| Mentions | 687 |
| Cited here | 92 |
| First — last | #1 — #729 |
| Top guests | Michael Ossmann, Jeff Keyzer, Andrew Witte |
| Related | fpga · arduino · firmware · analog to digital converter · raspberry pi |
A microcontroller is a small computer on a single integrated circuit: by the traditional definition it holds all of its memory, both program and data, internally, so that it can be programmed and can execute with no external chips.[528] The earliest devices consisted of a processor core with I/O ports and some internal memory, to which serial ports, UARTs and analogue-to-digital converters were progressively added until the modern part integrated nearly every peripheral a control application might need.[62] Because a microcontroller arrives packaged, tested and documented at prices that fall to a few cents in volume, it functions as the standard computing element in products ranging from domestic appliances to vehicles containing hundreds of them.[52][281][193][634]
History
Before dedicated microcontrollers existed, some functions were served by what might be called proto-microcontrollers: sound-playback chips containing no logic at all, configured through a paper form specifying trigger behaviour, which evolved into rudimentary state machines only generously described as programmable.[424] On the programmable-logic side, an early CPLD containing small SRAM blocks — 256 by 8 bits in one part — was sufficient to implement a microcontroller with its program stored inside the same chip, a capability no other programmable logic of the era offered and the direct ancestor of soft processor cores in FPGAs.[181]
Early commercial microcontrollers were mask-programmed: a customer sent code to the vendor and waited roughly sixteen weeks for parts, by which time the code had usually changed.[632] The Microchip PIC 16C84, released in 1993, was the first microcontroller that was neither UV-erasable nor one-time-programmable; it stored its program in EEPROM and could therefore be reprogrammed in circuit without a UV eraser or an expensive in-circuit emulator that replicated the whole chip.[24] Microchip had begun as an EEPROM memory maker losing money in a commodity market, and turned itself around by applying its EEPROM process to the PIC architecture to create field-programmable microcontrollers.[632]
Development tools were a further barrier. In the 1990s a development kit for a PIC could cost a couple of thousand dollars and was sold only through dealers to account-holding businesses, so an individual could not simply buy one.[490] Microchip was the first vendor to combine a reprogrammable microcontroller with a programming interface cheap enough to build at home or to hang off a PC serial port, at a time when competing vendors of the era sold development tools costing several thousand dollars.[413]
Architectural growth proceeded by accretion of peripherals.[62] Integrated UARTs became universal roughly twenty to twenty-five years ago; before that a design required an external UART chip, and that integration marks the practical divide between the microprocessor and the microcontroller.[524] Analogue-era mobile phones illustrate the earlier regime: they were built from an 8-bit microcontroller with external ROM because the code did not fit on chip, plus a serial EEPROM holding the electronic serial number in a standard bit-packed format; ROM images ran to 32–64 KB and every manufacturer used a different processor.[294] A further shift in board-level economics came with low-cost prototyping boards: in the early 2000s the BASIC Stamp cost more than one hundred dollars once imported into Europe with tariffs, which discouraged students from experimenting for fear of destroying the board, and on the Arduino programme Banzi set a target price of roughly twenty euros — about the price of a pizza and a beer — precisely to make destroying one inconsequential.[726] The spread of microcontrollers also ended the era of the logic probe, which had worked when a board was discrete logic in DIP packages that could be probed pin by pin against a schematic but could not be applied to microcontroller-based designs.[600]
Definition and boundaries
The traditional definition of a microcontroller is a part that holds all of its memory internally, both program and data; a device that must fetch its program from an external memory is by that definition a microprocessor, regardless of whether the interface is a parallel bus or SPI.[528] Practitioners increasingly define the category instead by design intent: high integration, low cost, low cross-system latency and a focus on I/O and hard real-time behaviour rather than processing throughput, with integration pursued because it is cheaper.[529] On that view a flashless part is still a microcontroller, and whether Flash belongs on the die is simply a cost question — embedded Flash requires additional and different process steps from plain logic, so leaving it off the die lowers silicon cost, and specialist Flash vendors make the memory more cheaply than a microcontroller vendor can integrate it.[529][713]
The boundary is illustrated by the Raspberry Pi RP2040, which carries 264 KB of on-chip SRAM but no internal Flash, supporting up to 16 MB of external Flash over a QSPI bus; embedding Flash would have required extra mask steps and it was omitted to hold the die cost down.[528] The part was designed from a clean sheet by engineers whose background was in large SoCs rather than microcontrollers, with goals of very low cost on a fairly modern process node and deterministic behaviour that a programmer could reason about; the first generation deliberately omitted security features and gave little attention to power consumption, so its deep-sleep modes are not competitive.[687] Its successor, the RP2350, adds a built-in switching regulator that steps 3.3 V down to the core supply through an external inductor and capacitors, and pairs two Cortex-M33 cores with two RISC-V cores.[676] Bus fabric choice also separates a microcontroller from a peripheral-hub chip: the RP2040’s small fabric reads a peripheral in one or two clock cycles for low latency, whereas a PCI Express-connected fabric feeding busmasters such as USB, cameras and displays trades a latency of around ten cycles for throughput.[648] Hybrid parts blur the boundary from the other direction: an STM32MP1 carries a Cortex-M4 with the peripheral set of a top-end STM32H7 — around twenty-two communication peripherals plus timers and ADCs — alongside two 800 MHz Cortex-A7 cores capable of running Linux.[515]
The decision to use an application processor rather than a microcontroller is usually driven by wanting an operating system, a large graphical display and networking, not by raw compute.[190] Where those needs are absent, the microcontroller wins on power: choosing a microcontroller over a Cortex-A application processor for a wearable platform is a power decision even where third-party application support argues for the larger part, and an early product of that kind ran a Bluetooth stack on an NXP ARM7 with 32 KB of Flash and a few kilobytes of RAM.[175] Running bare-metal code out of internal SRAM, with no external DRAM, gives a microcontroller sleep-mode power consumption orders of magnitude better than an embedded Linux system.[515] A common early partitioning question is therefore whether the product is a computer platform with a camera and display — in which case a Linux-capable processor follows — or a node doing sensing and control, in which case a microcontroller does; the fact that a part such as an ESP32 can drive a camera and display does not mean it should.[645] Embedded GUI toolkits distort this decision: free toolkits are workable but poor-looking, while commercial ones cost around ten thousand dollars in licence fees, significant against a low-volume product’s margins.[515] Development boards can further confuse it by silently removing the capability that motivated the part: on one embedded Linux board the parallel LCD pins were routed to an HDMI transmitter, and only a subset of the device’s I/O was brought out to any pin at all.[515]
Processor cores
8-bit and 32-bit parts
32-bit microcontrollers are not available in the very small packages 8-bit parts occupy: they carry large memories and complex peripherals, so they are physically larger and require substantially more initialisation code before they will do anything, and an 8-pin 32-bit part effectively does not exist.[47] The case for 8-bit parts is power and resource proportionality rather than cost alone: an application that uses a million transistors should not have to power up a hundred million.[489] Where a product is not price sensitive, however, Cortex-M parts are cheap and capable enough that choosing an 8-bitter is hard to justify, and peripheral fit rather than core width often decides the part — an 8051-based part such as the EFM8 can win a socket purely because its peripheral set matches the hardware, even where the processing requirement would be met by anything.[489]
Legacy and open cores
Legacy cores such as the 6502 and 8051 persist in new silicon because they are royalty-free: the 6502’s patents expired and Intel placed the 8051 in the public domain, whereas embedding an ARM core costs the chipmaker either a per-unit royalty or a fixed fee negotiated up front, which is why inexpensive display and touchscreen controllers still ship with 8051 cores.[169] The 8051 also supports fast context switching in hardware through four register banks: a task is assigned a bank, and switching context means telling the core which bank is live rather than pushing and popping the entire machine state onto a stack as a conventional CPU must.[169] RISC-V cores are offered in distinct microcontroller and application-processor classes, with an MCU-class core positioned between a Cortex-M4 and a Cortex-M7 in compute; the instruction set’s extensibility allows custom instructions to be offloaded to on-chip FPGA fabric to accelerate operations such as convolution.[525]
Microcontrollers and FPGAs
Microcontroller and FPGA silicon have converged from both directions: FPGAs gained hard processor blocks and microcontrollers gained small blocks of programmable fabric.[102] The two are complementary rather than competing, because non-trivial control logic whose timing is not extremely tight is far faster to write as imperative C on a microcontroller than to implement in fabric, which is the argument for pairing the two or instantiating a soft core.[395] Integration is the microcontroller’s practical advantage: a PIC handling USB and JTAG programming needs only a 3.3 V regulator and a few decoupling capacitors, whereas small FPGAs typically lack integrated regulators and accurate clocks.[395] USB in particular requires a clock accuracy that some PIC parts achieve without a crystal by trimming the internal oscillator on the fly against the synchronisation packets on the USB wires; FPGAs generally lack clock adjustment fine enough to do this and need an external clock.[395] An FPGA project is only worth the tooling cost when the task is not easily done on a microcontroller — massively parallel work or hard real-time decoding — rather than tasks such as blinking an LED.[419] Driving LED matrices is the canonical example: it becomes difficult on a microcontroller quickly because many pins must be driven in parallel with a bit-banged protocol at speed, while an FPGA handles the same job trivially by instantiating parallel units, which makes matrix driving a good first non-trivial FPGA project.[423] The same limitation applied in earlier decades: microcontrollers were unsuitable for logic analyser front ends in the 1990s because they were neither fast enough nor deterministic, which pushed such designs to discrete TTL or early programmable logic.[436]
Economics and vendors
A fifty-cent microcontroller arrives already packaged, tested and documented with a data sheet available to everyone, which is the economic barrier any custom-silicon alternative has to clear.[52] At consumer volumes of hundreds of thousands of units, a small ARM part such as an STM32 can be bought for around a quarter and other processors for under ten cents.[281] The cheapest conventional 8-bit parts, such as a PIC in a SOT-23-6 package, sit around thirty to forty cents; a three-cent microcontroller is an order of magnitude below that, and the difference only repays learning a new platform well into hundreds of thousands of units.[412] For a one-off or a build of ten to a hundred units the microcontroller price is irrelevant, so the rational choice is the most familiar and best-tooled part rather than the cheapest.[493] Within a family, the price step for memory is disproportionate: an otherwise identical part with 128 KB instead of 32 KB costs considerably more because memory occupies a large fraction of the die area.[676]
The breadth of the catalogue is itself a market feature: a single distributor can list on the order of eighty thousand microcontroller part numbers, many of them the same die in different packages, which makes vendor-neutral tutorial material for any specific part commercially unattractive to produce.[489] Renesas has been the world’s largest microcontroller manufacturer by volume, ahead of Microchip, Atmel and Texas Instruments, on the strength of very large design wins; that volume comes from white goods and automotive rather than from the maker or consultancy market, and a domestic appliance typically contains one of its 8-bit or low-cost 32-bit parts.[102][193] Microchip began an analogue products group around 1998 on the reasoning that customers designing in a PIC also needed op amps, brownout reset circuits, supervisors and regulators, and that the company already ran the mixed-signal processes required; microcontrollers now account for roughly half of the company’s revenue, the remainder coming from analogue, FPGAs and interface controllers acquired with companies such as Microsemi and, through it, Actel.[485]
Vendors also rebrand general-purpose microcontrollers as fixed-function parts: the MCP2200 USB-to-serial bridge is a PIC 18F14K50 USB microcontroller carrying preloaded firmware, sold with its own part number, data sheet and qualification.[30] Firmware in a microcontroller can itself be the product differentiator in either direction: an inkjet cartridge physically capable of 2,500 pages may carry a microcontroller that refuses to print after 500, with no difference in the cartridge itself,[303] and USB-C cables rated above three amps must be electronically marked, meaning a microcontroller in the plug answers a specific packet — a requirement that can be, and is, faked by cables carrying a fraction of the specified copper.[340]
Part selection
Free choice among microcontrollers is a cost, not a benefit, in a working design: an externally imposed constraint to reuse the part already in another product removes a week of comparison with little loss.[140] Selecting by parametric search for the cheapest part meeting the requirement, without regard to vendor, is a defensible strategy where the design does not depend on ecosystem or peripheral idiosyncrasies.[84] Ease of use is best measured by the breadth of open-source software support — a Zephyr port, a Renode model — rather than by vendor marketing, because a vendor-only toolchain behind an NDA imposes an ongoing cost and no escape route.[691]
Structural constraints narrow the choice further. Commoditised, multi-source footprints exist for 74-series logic but not for microcontrollers or switching regulators, so a microcontroller footprint effectively locks a board to one vendor’s part.[453] Substituting within a family during a shortage is rarely a drop-in: a single letter’s difference in the part number can halve the memory and the peripheral count and change the package, forcing a board respin, a firmware rewrite and a re-partitioning of the system.[587] Underestimating Flash requirements is a common and expensive error: a design budgeted at 32 KB that could not fit a USB Power Delivery stack had to move to a 128 KB part which was not footprint compatible, forcing an adapter from a TSSOP to a larger quad flat pack and, because of the mechanical space available, a flexible rather than rigid board.[468] Radio modules almost always contain their own microcontroller, so a design that wants to run all software on a separate host processor and use only the transceiver has a much smaller module choice and may be pushed to a chip-down implementation.[614]
Peripherals and operation
Some microcontroller peripherals run autonomously without code: a PIC can be configured to sample its analogue-to-digital converter at a fixed period and deposit results in memory with no CPU intervention, which is the same idea as the programmable-peripheral cores appearing in larger parts.[265] Where converter timing matters, clocking the ADC and DAC from an external source rather than the microcontroller’s own clock generator avoids the jitter that generator introduces.[265] Direct memory access controllers give a microcontroller genuine parallelism for communications: a DMA channel configured for a fixed twelve-byte sensor transfer signals a task only when the block is complete, leaving the CPU free for other work throughout the transfer.[581]
Microcontrollers reached USB self-sufficiency in stages: parts arrived with USB hardware and enumeration handled on chip, then with USB bootloaders preloaded so that only D+ and D− need connecting, and a sufficiently fast core can even bit-bang low-speed USB with no transceiver at all.[658] Dedicated external chips remain an alternative to on-chip peripherals in some functions: a capacitive touch controller such as the Tontek TTP223 in a six-pin SOT-23 costs under ten cents, offers sensitivity adjustable from about 1 pF to 50 pF, self-calibrates at power-up and emits a debounced, polarity-selectable output that can drive an ordinary microcontroller input or a wake-up interrupt, removing the need for touch peripherals or capacitive-sensing firmware.[477]
A field-updatable product needs a bootloader that resides in Flash, runs first at power-up, validates the application image and only then transfers execution; updating requires a documented path back into the bootloader and any communications channel — CAN, USB or a plain UART — capable of carrying the new image.[212] Over-the-air update pushes the network stack into the bootloader, and many microcontrollers physically constrain the bootloader region: the space is fixed rather than arbitrary, so a 64 KB part cannot simply be given a 32 KB bootloader containing a Wi-Fi stack.[432] Program Flash is typically specified for only around ten thousand write cycles, because a program memory is expected to be written a handful of times in the device’s life, unlike a data EEPROM.[428] Silicon errata are a routine input to microcontroller selection rather than an exception: a family’s errata list will contain defects marked fixed in a later silicon stepping and a substantial number marked with no fix at all, meaning an advertised feature simply does not work.[482]
Power
The honest figure of merit for microcontroller power is energy per instruction rather than current per megahertz, because one part may execute an instruction per clock and another one per four clocks; power per MIPS is better still, but data sheets do not publish it.[629] Comparing two parts is further complicated by their internal supply architecture: a core running at 1.2 V behind an internal linear regulator draws roughly constant current, so its power falls as the battery discharges, whereas a part using an internal or external switching converter draws roughly constant power, and the only sound comparison is to build both boards, run identical software and exercise every peripheral and sleep mode.[629]
The most effective low-power firmware strategy is to keep the active period short rather than to micro-manage clock trees: wake, complete the task immediately, and sleep, avoiding any state in which the microcontroller is awake waiting on a sensor.[527] Not every peripheral offers a low-power mode reachable over its control bus, so the fallback is a load switch cutting supply to that subsystem entirely; this in turn creates a back-powering hazard through the signal lines into the unpowered part.[527] Bulk or off-brand bypass capacitors can carry enough leakage to dominate a low-power design’s sleep current, so capacitor selection is a power-budget item and not only a decoupling one.[527] Measuring the current of a connected microcontroller is itself difficult because of dynamic range: sleep currents and transmit-burst currents can differ by several orders of magnitude within one duty cycle.[301]
Interfacing and system design
Microcontroller and 74HC-series data sheets carry two distinct output-current limits: a maximum per pin, often around 30 mA, and a separate maximum total current through the ground or supply pin, often around 200 mA, so a high pin-count part cannot source the per-pin maximum from every pin simultaneously.[16] Directly driving LEDs from pins is viable where only a few are lit at a time; at roughly 30 mA per LED with eight on simultaneously the design sits just inside a typical part’s maximum total pin current, with a 74HC595 shift register as the alternative.[16] Driving a large LED matrix from a single processor fails on bandwidth rather than on drive current — one CPU feeding fifty shift-register modules cannot keep up — so the standard remedy is a local microcontroller per 8×8 tile with the controllers exchanging data.[16]
Cheap microcontrollers have moved processing across isolation barriers: rather than routing many analogue converters back to a single processor across an isolator, designs now place a microcontroller on the isolated side and send digital data across.[148] Per-cell battery monitoring exploits the same idea by giving each cell its own microcontroller powered from that cell, using the part’s internal ADC and voltage reference, with an optocoupler carrying serial data out of the cell’s floating voltage domain.[112] Industrial 24 V I/O is interfaced to a 3.3 V or 5 V microcontroller through optocouplers: the input side takes the 24 V loop and the open-collector output provides a low-voltage, low-current signal, with the arrangement reversed on the outputs and a triac driven through the optocoupler for AC loads.[620] Opto-isolated CAN transceivers exist specifically to separate the microcontroller from the bus; more generally, bus drivers serve both to isolate and to supply the current needed to drive the line capacitance.[518] Where extra conductors are prohibitively expensive — such as sixty feet of cabling in an electronic drum kit — control data can instead be carried as a modulated high-frequency carrier superimposed on the existing 12 V DC supply and demodulated by a microcontroller at each end point.[424] Analogue vendors increasingly integrate a microcontroller alongside converters, which forces a designer who wanted only a converter to program the embedded core rather than simply talk to the part.[148]
In instrumentation, sampling oscilloscope bandwidth is set entirely by the front-end sample-and-hold, so once a sample is captured the conversion can be arbitrarily slow; a design achieving multi-gigahertz front-end bandwidth can use the ADC inside an inexpensive PIC to digitise the held value.[178] A software-defined power supply can close its control loop in firmware if the converter is fast enough: an XMega chosen for a 2-megasample, 12-bit successive-approximation ADC gives a short enough lag between sample, regulation decision and DAC or PWM output to regulate in software.[640] A direct digital synthesis function generator is architecturally a microcontroller issuing SPI commands to a DDS chip such as the AD9837, with the DDS setting output frequency from DC up to its own limit; the microcontroller adds no signal path.[554]
Pin count, not compute, often drives the choice in display designs: driving thirty-two segments plus eight commons requires at least forty dedicated pins, and the larger package that offers them comes with a larger die and far more memory, tripling the chip price, so an external LCD driver on an SPI bus is cheaper and also lets the display driver and the microcontroller sit on opposite sides of the board, easing layout and signal integrity.[393] Against that, moving a function into a dedicated external chip to save pins or memory adds a bill-of-materials line that can go obsolete or become unobtainable, and a part not stocked at ordinary distributors must be bought in quantity with no substitute available if it disappears.[393] Partitioning between chip and board turns on confidence: blocks that are proven and would add another supply or another failure domain go on-chip, while anything whose behaviour is still uncertain — particularly firmware-controlled functions — goes on a microcontroller next to the chip with a bus between them.[483] A microcontroller can also replace substantial amounts of discrete logic outright: designs requiring twenty to thirty 74-series packages collapse into a single small part costing a few cents, though the discrete version remains the better teaching example for timing-critical pin driving.[612] Pin-multiplexing options remain poorly expressible in schematic capture: a net on a microcontroller may legally connect to any of several pins, but only in particular permutations, and CAD tools generally cannot represent that constraint.[135]
Firmware and development practice
Bringing up a new microcontroller costs a couple of weeks of work to move smoothly between its interfaces and to learn its internals and limitations, a real schedule item rather than a formality.[661] The investment is transferable capital within a family: six months spent on one Kinetis part made porting a core operating system to any other member of the line a sub-day exercise.[336] An interactive bus tool that sends protocol transactions from a terminal removes the edit-compile-program-test loop when learning an unfamiliar chip, and isolates whether a fault lies in the protocol, the chip or the wiring.[125] Debugging aids consume the resource that is scarcest: printf output over a serial terminal costs a couple of kilobytes on a part whose memory is measured in tens or hundreds of kilobytes rather than megabytes.[541] A productive way into unfamiliar firmware is to locate the code that touches a known I/O pin — for instance the pins wired to an external serial EEPROM — and then work outward through the calls to that routine, which quickly identifies the code handling the data of interest.[294]
Language choice carries measurable cost: a given microcontroller running an interpreted high-level language does roughly an eighth of the work at roughly eight times the execution time, which is the concrete trade being made for development speed.[479] Getting a Python implementation to run on a microcontroller at all is substantial engineering; MicroPython, created by Damien George, targets a relatively technical audience, and CircuitPython is a derivative retargeted by Adafruit at the Atmel SAM D family with a more hardware-oriented interface.[383] A layered API is what allows a beginner platform to remain useful at depth: an LED can be blinked in about seven lines at the top layer, and a developer who needs finer control can strip a layer and work against a more granular interface on the same hardware.[726]
Teaching against a specific microcontroller rather than an abstract model is what transfers: the durable skills are talking to registers, writing legible C, interfacing hardware and debugging hardware through the code written for it, none of which is tied to the part chosen.[413] A general-purpose programming curriculum still benefits from teaching pointers early through C or C++, because understanding how the microcontroller actually works underpins the rest.[329] Microcontrollers do not remove the need for fundamentals: an on-chip ADC still usually needs an amplifier in front of it, so discrete and gate-level design remain prerequisites rather than superseded knowledge.[4] Abstraction layers carry a direct silicon cost in high-volume products — generated code running four or five times the size of the application forces a larger microcontroller, and multiplied across millions of vehicles a single coding-standard decision can be worth tens of millions of dollars — and abstraction is in any case a poorer fit in embedded systems than in general computing, because low-level behaviour propagates upward and affects the result, so hiding the hardware hides the things the engineer must know.[634]
Computation at the limits
Machine learning on microcontrollers works by splitting the workload: the model is trained on servers and only the resulting inference model is loaded onto the part, so a Cortex-M4 performs inference rather than training.[449] Video codecs are the limit case for microcontroller compute: without a hardware decoder, decoding H.264, H.265 or AV1 in software is not feasible on a microcontroller, so streaming to such a device requires a lightweight custom compression scheme for simple graphical content.[638] Precomputing a bit stream on a host and shifting it out of a microcontroller lets a simple part synthesise complex signals it could never compute in real time: the firmware holds only a table and has no representation of the waveform it is producing at 900 MHz.[667] Timing-critical sequencing likewise belongs on chip: frequency hopping across a span wider than the receiver’s instantaneous bandwidth must be implemented in the microcontroller firmware rather than commanded from the host, because USB latency added to the roughly hundred-microsecond retune time exceeds the gap between packets — a little over 200 microseconds in Bluetooth, which itself spans 79 MHz against a 20 MHz instantaneous bandwidth.[161] Distributed motion control can keep multiple microcontrollers in step by moving the scheduler to a host: a Linux process sends timed packets over USB to each microcontroller so that step timing on a moving head stays synchronised with the base.[686] Even hardware weaknesses can be exploited: a network of ATtiny44A boards each clocked from its own wide-tolerance internal RC oscillator ran asynchronously with slightly different timing, which was exactly the behaviour the model required.[330]
Production, repair and chip bring-up
Programming and test are separate stations in volume production: a board carrying three microcontrollers and two SPI Flash devices passed through five stations, one per programmable device, before reaching a bed-of-nails self-test fixture and only then final assembly.[461] Consumer instruments frequently expose an undocumented in-circuit programming header for the internal microcontroller, but a rebranded, house-marked part defeats third-party repair because the replacement chip cannot be identified or sourced.[554] Microcontrollers also make retro and obsolete hardware repairable: a small microcontroller or FPGA can replicate a failed function, which is how emulated SCSI disks, keyboard adapters and similar substitutes for unobtainable subsystems are built.[463] Where a chip must be verified as a design rather than as a package, an accelerator ASIC is treated as a slave to a microcontroller: the firmware and the parallel interface between them are brought up against an FPGA port of the same RTL, because the ASIC itself will be about nine months at the fab.[721]
Security
A modern car is a network of interconnected computers with a microcontroller in each subsystem: a low-end car has around twenty electronic control units, an average car around fifty and a high-end car up to a hundred, and each LIN bus below them carries a further five to ten microcontrollers across several dozen LIN buses, giving totals of the order of five hundred to seven hundred microcontrollers per car.[634] That makes the attack pattern the same as a corporate network: compromise any one node, including a peripheral one such as a tyre-pressure sensor, and use it as a foothold onto the shared bus.[265] Tyre pressure monitoring systems are of particular interest because each of the four sensors independently and periodically transmits a radio signal to a central controller, putting identifiable data outside the vehicle.[265]
Encrypting a firmware image with a key pre-programmed into the target microcontroller lets a manufacturer send the binary to a contract assembler anywhere: only devices already holding the key can program it, though the protection is only as strong as the difficulty of extracting the key from the die.[239] Firmware extraction is structurally easier on Linux-class devices because their storage is external and can be read with a suitable flash reader; on a microcontroller with internal Flash the attacker’s first question is whether the debug interface was left enabled, and where it was locked out, fault injection or glitching the device into a state that divulges the firmware is the remaining route.[698] The same containment principle is used defensively: a hardware wallet’s security model is that the private key stays inside the microcontroller or secure element and never reaches the host — the host sends a transaction, the device displays the details for physical confirmation, performs the ECDSA sign operation internally and returns only the signature.[418]
Environmental and regulatory constraints
European CE marking rules have been extended so that essentially any product containing a microcontroller must be field updatable, which rules out designs built on one-time-programmable memory.[720] Radiation-induced bit flips make microcontroller-based designs a mission-duration question in space: for a six-month low-earth-orbit CubeSat the probability of an upset is low, but for a five-year mission in an orbit that will not decay for a decade it is not, particularly where the device cannot be reprogrammed.[401] Replacing a microcontroller-based maximum power point tracker with an analogue one eliminates stored state, which is what radiation corrupts: an analogue loop recomputes continuously, so a particle strike produces a transient the feedback corrects, and the failure mode becomes gradual degradation rather than sudden loss.[401]