| Episodes | 280 |
| Mentions | 653 |
| Cited here | 77 |
| First — last | #1 — #728 |
| Top guests | Jeff Keyzer, Marcus Schappi, Tony DiCola |
| Related | raspberry pi · open source hardware · microcontroller · kickstarter · linux |
Arduino is an open-source electronics platform comprising a family of microcontroller development boards and the integrated development environment (IDE) used to program them.[413] There is no Arduino microcontroller: the name denotes a board standard together with the software environment layered on top of it, and the part beneath the classic boards is an Atmel AVR.[413] The platform descends from Wiring, a student thesis project, and from a 2003 prototyping board, which Massimo Banzi, Tom Igoe, David Cuartielles and David Mellis rebuilt into a new platform.[726] The hardware designs are published under a licence that permits anyone to manufacture functionally identical boards, while the Arduino name is a trademark that may not be applied to the results.[6][40]
History
Origins
The platform descends from a 2003 prototyping board and from Wiring, a student thesis project, which were rebuilt into a new platform by Massimo Banzi, Tom Igoe, David Cuartielles and David Mellis.[726] The development environment was made by taking Processing, a language and environment built for designers and artists to program desktop computers, removing Java and substituting C++.[726] The open licence was applied to the hardware deliberately, before the term open-source hardware existed, so that others could build on the design.[726]
Manufacturing was local from the start: Ivrea, the site of Olivetti’s electronics industry for decades, retained board fabrication and assembly within a fifteen-minute drive, and Arduino continued to manufacture a large share of its production there.[726] The name comes from a bar in Ivrea named after a local king, and the term “shield” for a stacking expansion board followed from the observation that a board placed on top of an Arduino is a king’s shield.[726]
Examples were written into the environment itself rather than left to be found, with two weeks spent writing them before release, on the reasoning that a beginner opens an example, runs it, and then changes one number to see what happens.[726] The IDE was deliberately held to seven buttons for twenty years, a product decision taken by interaction designers rather than a technical constraint.[726]
Precedents
Low-cost microcontroller development predates Arduino. Microchip’s PIC became the hobbyist default because it was first with low-cost programming tools, including do-it-yourself serial-port programmers, at a time when other microcontroller vendors sold multi-thousand-dollar development systems.[302] The PIC 16F84 replaced the EEPROM-programmed 16C84 with flash while keeping in-circuit reprogramming, and a programmer hooked to a PC serial port is what first put low-cost microcontroller development within reach of individuals.[413] The Parallax BASIC Stamp anticipated the bootloader mechanism a decade earlier: it shipped with a bootloader already programmed into the part, so a program could be loaded over a serial port with no dedicated programmer.[570]
The stacking-board pattern was established long before Arduino by PC/104, a standardised outline with defined mounting holes and 0.1-inch board-to-board header pins functionally equivalent to the PC ISA bus, in 8- and 16-bit versions, with male pins below and female above so boards stack indefinitely.[362] The PC/104 board measures about 90 by 96 millimetres and takes its number from the 104 pins of its bus connector.[362] Arduino’s step beyond the low-cost programming tools that preceded it was ease of use rather than price alone.[302]
Board line
The Arduino Leonardo moved the USB interface into the main microcontroller by using an ATmega32U4, removing the separate USB-to-serial chip; PJRC’s Teensy had already used the same approach.[61][235] The Arduino Due broke the 8-bit AVR line by running an Atmel SAM3X ARM Cortex-M3 at 96 MHz.[61] The Arduino Ethernet put Ethernet on an Uno-class board but omitted the USB interface, so programming it requires an external FTDI cable.[123] The environment later gained a compiler back end for the ESP8266, so the module could be programmed from the same IDE; before that, the options for the part were C or Lua.[326]
The platform’s software was formally pre-release until version 1.0, and the 1.0 API change broke a large part of the existing third-party library base, which then had to be rewritten.[80]
Trademark dispute
Arduino was founded by five people who signed a contract assigning the trademark rights to the company itself.[242] One founder separately registered the Arduino trademark in Italy through his own company, so that entity held the Italian mark, which produced the split between arduino.cc and arduino.org and litigation between them.[242] The other founders learned of the separate registration about a year after the company was formed and spent four or five years attempting to resolve it, with royalty payments having stopped twelve months before the matter became public.[242] The dispute ended with the buy-out of Federico Musto, who controlled Arduino AG and with it the trademark, leaving Massimo Banzi’s side owning the company and the mark outright.[354]
Operating-system underpinnings
A sketch-level API needs an operating-system layer beneath it to carry networking stacks, since silicon vendors do not abstract at that level themselves; that requirement drove the platform’s move from mbed to Zephyr.[707] mbed OS had been sustained by ARM paying its own engineers to write vendor support across parts from different silicon vendors; when that funding stopped the ecosystem reached end of life, and Zephyr activity rose over the same period.[707] Zephyr’s linkable loadable extensions allow code to be loaded at runtime onto an already-running system, which fits the sketch model: the plumbing stays resident and the user’s sketch is hot-swapped in on top of it.[707] The Uno Q, priced at about forty-four dollars, is a compact Linux machine wrapped in tooling built on containers and micro-containers, so that the user works entirely through the tools and never touches Linux directly.[707][726]
Hardware
Board design
The classic Arduino board carries no distinguishing hardware: a socketed microcontroller, a shield expansion header and almost no support circuitry, and what differentiates the platform is the software layer wrapped around that part, originally the Wiring programming interface.[2] The minimum Arduino-compatible hardware is close to the microcontroller alone, which is why an Uno can be shrunk to roughly the footprint of the chip it carries.[189]
Bringing analogue inputs out on the board itself removes an early obstacle: without on-board analogue-to-digital conversion a designer must add and talk to a separate converter before reading any sensor.[2] The classic Arduino’s analogue input spans zero to five volts against the internal reference rather than a precision external voltage reference, which limits absolute measurement accuracy.[25] The power design is a single wall supply linearly regulated to five volts, whereas an FPGA-class design needs separate rails around one volt for the core, 1.8 V for high-speed transceivers, 2.5 V, and 3.3 V for input and output, with seven or eight rails not unusual.[9]
Headers and shields
The expansion header uses 0.1-inch pin spacing, the grid against which reusable module designs are expected to hold so that others can breadboard and stack against them.[25] The irregular gap between two blocks of the header began as a layout mistake that was then carried forward for compatibility, so every shield since has had to reproduce it.[61] The stacking format works because a third party need only make a plain printed circuit board and place it on top, and the irregular outline has the side effect of making the board recognisable and helping the user orient it.[726] Stackable pin headers in the Arduino style and castellated board edges are the two module interfaces usable across the widest range of applications, whereas schemes needing press-fit studs and separate mounting hardware add parts and assembly steps.[530]
Arduino shields are identified manually, the user selecting the matching library for whatever is plugged on, whereas the Raspberry Pi HAT scheme puts an EEPROM on the add-on so the host can identify it and configure the multiplexed pins itself.[235] Where a shield communicates with its host over a plain serial link, the same board can be driven by anything else with a serial port, a single-board computer or a PC included, and the supplied Arduino library is only a convenience wrapper over documented low-level commands.[258] A shield supplied with unsoldered headers will not work when merely seated on the board: the pins must be soldered to the shield, a failure common enough to show up as returned kits.[331] The headers are a prototyping and stacking convenience; a custom board normally drops them and routes the signals where the design needs them.[166]
Manufacturing
A bare-board product avoids the largest fixed costs of a consumer product — enclosure tooling, plastics and finishing — because the panelised board snapped apart is the finished item, which is a substantial part of why development boards are cheap.[1] Some microcontroller crystal oscillator circuits need a resistor in parallel with the crystal to bias the inverter into its linear region; the AVR does not, and a board that shipped with that resistor absent still ran correctly.[11] A component that is not electrically necessary may still be fitted for radiated-emissions margin during certification, and a functional power-on test will not detect its absence, which is how a board missing a part passes electrical test and ships; missing-component escapes of this kind are caught with automated optical inspection that checks every board for absent or misplaced parts as it leaves the line.[11]
Software
Toolchain
Technically the platform is ordinary C with a set of pre-written libraries plus an editor that compiles and downloads to the board in one step; the novelty is packaging rather than language.[166] The Arduino has no interpreter resident on the board: sketches are compiled on the host to native code and the machine code is what runs.[339] Arduino code is compiled ahead of time — it is C and C++ underneath, transformed into valid C before compilation, so the desktop machine does the optimising and what reaches the board is instructions the processor executes directly.[383] The toolchain is GCC driven from a graphical front end; enabling verbose output in the IDE exposes the compiler and upload commands actually being run.[323] The download bundles a specific build of avrdude and the rest of the toolchain, so the user gets a known-good baseline instead of installing and version-matching the flashing utility separately.[152] Because the compiler sits hidden behind the graphical front end, the underlying architecture became irrelevant to the user, and PIC- and ARM-based boards followed the original AVR line.[354]
A defining property of the Arduino is that it needs no external programmer: the board attaches directly to USB, whereas an equivalent PIC development board carries a second chip acting as in-circuit debugger and programmer.[43] Programmer-free loading is achieved with resident bootloader firmware inside the microcontroller that accepts a new sketch over the serial link.[43] The threshold that makes a cheap part usable in the Arduino sense is being able to flash it over USB without a separate programmer.[637]
Programming model
Bare AVR or PIC development requires configuring registers by hand before any peripheral does anything, so that opening a serial port or toggling one bit costs real effort; the Arduino libraries exist to remove that step.[7] Arduino applies two abstractions at once: the user need not know which processor is fitted, and input and output are performed by calling a written routine such as digitalWrite instead of writing the port register directly.[413] The design principle is layered encapsulation: blinking an LED takes about seven lines at the top layer, a user needing more control strips a layer to reach a more granular API, and can descend further to plain C on the microcontroller.[726] Because every sketch reaches the hardware through those routines, the same source runs on an Atmel, a PIC, an ARM, an MSP430 or an Espressif part without change; the portability is a property of the library layer, not of the language.[413]
What makes a board an Arduino is the development environment rather than the header layout: the code must compile and run under the Arduino IDE against its libraries, and everything else is optional.[166] analogWrite does not generate a waveform in software: it configures the hardware timer registers, and on the Uno which of timers 0, 1 and 2 is used depends on which pin was named.[599] The Arduino execution model is a single sequential program running in a loop; adding networking usually forces a real-time operating system, and a full Linux stack on the same board is no longer deterministic.[146] The standard delay function busy-waits at full current, so a battery-powered compatible board substitutes a sleep call that the programmer must use in place of the familiar delay.[226]
Library ecosystem
Duplicate implementations proliferate in the library ecosystem, with a search for an Arduino infrared library returning pages of independent versions; experienced engineers still rewrite them after being burned by days spent debugging someone else’s code.[158] The ecosystem rests on a backend index describing available boards and pullable libraries, and most sensor vendors ship Arduino drivers, so straightforward example code exists for a part before any other framework has support for it.[653] A library that includes Arduino.h with the wrong letter case compiles on a case-insensitive Windows filesystem and fails on Linux, a portability failure that presents as a bug in whatever tool first exposes it.[599] A browser-based Arduino simulator compiles the sketch server-side with the Arduino command-line interface to exactly the hex file a local build would produce, then executes that hex in an AVR instruction-set simulator in the browser; rendering LED brightness faithfully under pulse-width modulation requires a moving average of on-time per frame and a gamma correction, since perceived brightness is not linear in duty cycle.[599]
Licensing, trademark and cloning
The Arduino hardware is released under a licence that permits a third party to manufacture a board with identical layout and pinouts; nothing in the design files restrains reproduction.[6] Open source hardware is distributed under a licence rather than placed in the public domain, so a company cannot simply take the design, close it and sell it as its own.[114] The project separates the open hardware licence from the name: the design files may be copied and an identical board produced, but Arduino is a trademark and cannot be applied to the result.[40] Arduino at Heart is a licensing programme that lets a third-party product carry an Arduino mark on the basis that Arduino technology sits at its core, as an alternative to the product being taken into the official board line.[189]
No open-source licence restrains offshore reproduction of a board; the choice of licence changes nothing about whether a design will be copied and sold at a lower price.[6] An open hardware design gives its originator no protection against a competitor manufacturing the same board at volume and undercutting them, which is the structural weakness of an open hardware business.[26] A bare board with parts on it offers no differentiation against a copy beyond branding, whereas a product with an enclosure differs in mechanical CAD, plastics, switch feel and layout, because a cloner would have to redo all of it.[298] The structural problem for an open hardware company is that value accrues to the silicon vendor and to cloners rather than to the platform: Atmel and later Microchip kept selling large volumes of the ATmega328 while the boards themselves were copied.[726] PJRC keeps the Teensy bootloader closed because giving it away would remove the reason to buy the board, making the bootloader the commercial asset of an otherwise open design.[713]
A genuine Arduino sold for roughly twenty to thirty dollars while clone boards of essentially identical function were available for eight to ten dollars; by the late 2010s an Arduino-compatible board could be bought for around two dollars delivered.[193][413] A reseller of Arduinos or clones has no room to charge a premium, because the product is identical everywhere and the price is therefore set at the bottom of the market.[201] An open hardware project cannot be carried on donated effort the way a software project can, because physical boards must be manufactured and bought, which requires capital.[242] Sustained open hardware platforms are produced by resourced companies rather than individuals: around 2011 the Arduino organisation turned over roughly five million dollars a year, Adafruit about a million and SparkFun about ten million.[22] The overwhelming majority of users of an open hardware product buy the finished, supported board rather than building from the published files, so an open design with nobody manufacturing and supporting it at a good price does not reach users at all.[22] Volume in the hobby channel is small in silicon terms, on the order of a hundred thousand boards across about five years, so presence on a development board is a poor proxy for a part’s production volume.[31] By the mid-2020s Arduino sold about two million boards a year and still took roughly eighty per cent of its income from hardware, against some fifty million dollars of venture capital raised.[707]
Compatible platforms
In practice the name denotes a compatibility layer rather than a specific chip: it is a common target meaning straightforward microcontroller work regardless of the silicon underneath.[403] An exact clone shares the original’s software ecosystem, so work done on it feeds back to the same body of code; a merely similar board with its own drivers forms a separate, incompatible ecosystem.[300]
chipKIT, built by Digilent around Microchip’s PIC32, put a 32-bit part behind the Arduino programming model in two boards, the Uno32 and the Max32, matching the Uno and Mega outlines.[43] Digilent had moved its boards from AVR to PIC32 early on for cost and performance reasons independent of Arduino compatibility.[302] Energia is a fork of the Arduino project that compiles Wiring sketches for TI LaunchPad boards; because the upstream IDE carried mostly Arduino targets, forking was the route to supporting other silicon.[212]
The Teensy is a compatibility layer that keeps the Arduino programming model while substituting a far faster part, an i.MX RT in place of an ATmega328P, so an existing super-loop program can simply be run faster without restructuring.[713] Its distinguishing value is a software layer over a much faster part, including an audio library in which audio connections are composed graphically, while the board can still be programmed as an Arduino or written in plain C; it offered USB human-interface-device capability with an Arduino-style environment before the Arduino Leonardo did.[313][235]
Linear Technology’s Linduino line is an Arduino-compatible demonstration board carrying sketches for the company’s parts, priced around seventy-five dollars; a vendor demonstrating a digital-interface part needs a host to talk to it, and standardising on one common platform avoids maintaining a separate demonstration board for every chip in the catalogue.[230] The Light Blue Bean is an Arduino-compatible Bluetooth Low Energy board with no connectors at all, programmed wirelessly over BLE; a lower-power microcontroller was rejected for it because keeping the ATmega meant existing Arduino code ran unchanged, source compatibility being valued above the power saving.[226] The Intel Galileo carried an x86 core but emulated the Arduino input and output through an I2C expander, which made pin operations very slow despite the more powerful processor.[490]
Boards that run MicroPython, the Atmel SAMD and ESP parts among them, also run Arduino, so the interpreter firmware can be erased and the board reused under the Arduino IDE if Python does not suit.[323] The SAMD21’s appeal for education-oriented boards is that it is an automotive-grade part with an on-board DAC, ruggedised peripherals and generous memory, which matters when users will connect things wrongly; it is not a cheap part.[587] The Arduino Mega outline persists in 3D printers, where aftermarket controller boards carrying stepper drivers plug on top of it as shields, and that installed base is what makes a faster board in the same outline a useful upgrade.[623] USB can be bit-banged in software on a fast enough part: on a 160 MHz ESP8266 a low-speed device was implemented by reading or writing one bus bit every 53.333 cycles and running the protocol in firmware.[637]
Applications
The platform is positioned as a springboard for physical computing work such as stage props and product prototypes, reaching working embedded behaviour without committing to a custom printed circuit board.[11] A common commercial route is to prove the product fully functional on an Arduino and then hand it to an embedded engineer who reimplements it on a production microcontroller such as a PIC.[379] Choosing parts that already have established module and library support buys both supply availability and a choice of existing libraries for whoever maintains the design later.[309] For freelance client work the argument for the platform is handover: the toolchain is free, the client can find many people able to modify the result, and the consultant need not remain involved in future changes.[309]
The ArduPilot autopilot ran a working multirotor control loop on an 8-bit processor at roughly sixty to seventy per cent of its capacity, which places autopilot quality in the control algorithms rather than in clock speed; extra processing headroom on a flight controller is spent on running the estimation loop faster, for instance sensor fusion at 400 Hz instead of 100 or 200 Hz, and on hosting a real-time operating system so that adding a feature cannot disturb the timing of existing ones.[105] The InvenSense MPU-6000 contains a digital motion processor that performs sensor fusion inside the chip, freeing that work from the flight controller.[105] Autopilot hardware carried a CAN bus for communication between aircraft subsystems before standards for UAV CAN communication existed.[356]
On his own projects, James Bruton ran a twelve-degree-of-freedom quadruped from 8-bit Arduinos computing inverse kinematics for every joint at once, commanded through a six-axis controller built from two three-axis joysticks; a requirement for six serial ports forced a three-board architecture, one master feeding two slaves, which a single CAN bus controller replaces once the motor drivers support CAN, and moving the same code base from 16 MHz 8-bit boards to 180 MHz 32-bit Teensy boards is better than a tenfold increase in clock rate.[416] The MaKey MaKey is an Arduino with capacitive input pads that enumerates as a USB human interface device and issues key presses when a pad is touched, while remaining reprogrammable as an ordinary Arduino; SparkFun manufactured and shipped 11,000 units of it.[189] A product can ship in its earliest form without a designed circuit board at all: the first units of Jason Huggins’s commercial robot used an Arduino, a shield, a mini breadboard and six jumper wires in place of a board.[369]
Jon Oxer put a vehicle permanently online with a low-power router-based computer and 3G modem in the boot, a microcontroller wired into the ignition system for start, stop and locking, and an OBD-II link into the engine management system for live data and position logging.[123] A shield can bridge into a proprietary ecosystem: one exposing the Lego Mindstorms NXT connector let the light sensors, touch sensors, motors and motor encoders be read and driven from Arduino code, pairing Lego’s mechanical prototyping speed with the electronics side.[167] A stackable form factor lets the expensive or scarce board be reused: the controller lifts off a wired-up stack of shields and moves to another project while the shields stay connected.[202] Once a module and a library exist, a formerly specialist task collapses to a few lines: receiving an SMS on a microcontroller and displaying it on an LCD takes about ten lines of code.[233]
The platform is a standard instrument for reverse engineering. An undocumented serial LED protocol can be recovered by capturing the controller’s data line with a logic analyser and replaying the decoded stream from a microcontroller, which is how Samy Kamkar drove proprietary addressable light strings without documentation.[308] An undocumented sensor initialisation can be recovered by capturing its I2C traffic, decoding it against a database-driven register map so each read and write is labelled with register and bit fields, then writing a sketch that reproduces the identical transaction sequence.[155] Consumer remote controls cluster in the unlicensed bands, mainly 433 MHz and 315 MHz with the choice country-dependent, so a receiver shield presenting the raw demodulated waveform is enough to reverse-engineer garage door openers, remote power boards and wireless weather stations; a dependable way to control a proprietary radio device is to gut one of its factory remote controls and wire across the back of its buttons, driving them from a shield’s outputs.[349] A retro computer kit with only a mask ROM and static RAM can be loaded without reprogramming the ROM by bit-banging a serial stream from a microcontroller into its joystick port, using the loader already in the ROM.[391]
Porting Grbl from an 8-bit Arduino target to a 32-bit part is close to drag-and-drop for the motion planner because both are C; the work lies in bringing up the peripherals first — three timers, a PWM channel and the interrupt and pulse handling — after which the rest plugs in.[438] A controller part without integrated radios forces extra modules and interconnect onto the board; the ESP32 displaced one such design by combining a cheap, small package with the radios already on chip.[438] ESP modules cost a dollar or two alone and finished development boards using them sell in three-packs for eight to twelve dollars, which is the price level at which designing a home-automation node from scratch stops paying.[657]
Limitations and trade-offs
A full Arduino board carries USB interface, regulator and connector circuitry that an embedded application does not use, so embedding a thirty to forty dollar board is expensive relative to the function drawn on; the cut-down variants exist to strip that overhead.[25] A modular board plugged together through a known header is right for prototyping and usually wrong for production: connectors add cost, the form factor is not optimised for the enclosure and power consumption is not tuned, unless the product is a high-margin niche item where a module’s cost does not matter.[491] When a prototype assembled from off-the-shelf boards is to be built two hundred times, consolidating everything onto one printed circuit board and resolving the connectors is easier than replicating a cabled stack of dev boards.[524] The claim that the platform does not scale needs qualification: because the design is open, it can be stripped back to the bare microcontroller and reproduced cheaply, so the scaling limit lies in the system architecture rather than in the board.[524]
Prototyping on an Arduino commits the eventual product to the ATmega, because the code and libraries are written against that part; a compatible platform on a different architecture reopens the choice of production microcontroller.[43] The bottom of the Cortex-M0 range and the top of the ATmega range do not overlap: the smallest 32-bit ARM already offers more than the largest 8-bit part, so the migration is not a trade of one capability for another; the concrete reasons for leaving the 8-bit Arduino-class part are clock speed, flash size, peripheral set and the integrated USB and LCD controllers.[281] One autopilot project dropped AVR support around 2008 and moved to the STM32 because fitting the code onto the 8-bit part required disabling most of the functionality.[356] Once a network stack, some data storage and general input and output are added, a 328-class part runs out of pins and memory, which is the argument for pairing Ethernet with the larger Mega-class microcontroller instead.[123] Running a Wi-Fi stack on the same 8-bit microcontroller that runs the sketch consumes most of the available resources, which is why plug-in Wi-Fi and Bluetooth modules normally carry their own processor for the stack and expose a simple SPI or I2C interface to the host.[146]
The platform’s defining property is that it abstracts the microcontroller away from the user, which is at once the source of its accessibility and of what its users never learn about the part; because the platform hides register configuration, clocking and input-output setup, coursework whose purpose is to teach those mechanisms excludes it.[413][124] The Arduino language is a thin surface over C++; the simplicity holds only until the user needs something the surface does not expose, at which point they are working in the underlying C++.[329] Using the platform still requires embedded programming and electronics knowledge, and anything web-connected adds networking and web services on top.[189] The ATmega beneath the abstraction is a production-worthy part, so a project that outgrows the environment’s memory or timing limits can keep the same silicon and add a JTAG debugger rather than change architecture; because the part underneath is an ordinary AVR, a design built on the Arduino layer retains the fallback of programming the same silicon directly in C.[187][80]
The usual progression is from the Arduino board to designing one’s own microcontroller board with surface-mount parts, which is the step at which producibility and layout practice first matter.[573] Connecting a servo motor directly to a microcontroller input-output pin is a characteristic intermediate-level failure, and knowing to insert a driver stage is exactly the gap between making an LED blink and building a working machine.[550] In beginner workshops the first hour is routinely consumed by installing the development software, configuring it and connecting the board, overhead that a board presenting itself as a filesystem or a live interpreter removes.[323] The compile-and-upload cycle repeats on every change, whereas an interpreted runtime is loaded once and then updated interactively, which removes a recompilation from every iteration; for speed and power the compiled Arduino path outperforms CircuitPython, with MicroPython between them.[599][383] MicroPython follows desktop Python in letting time-critical or register-level work be written as C functions and called from Python, and the SAMD NeoPixel driver was ported by taking the existing Arduino NeoPixel routine, which contains GCC inline assembly for the bit timing, wrapping it in the signature MicroPython expects and disabling interrupts around it.[323]
A protocol bit-banged from a general-purpose board may succeed only one attempt in ten, which is acceptable for a one-off investigation but not for a shipping product, where reliability, repeatability and manufacturability narrow the usable set of techniques sharply.[346] Breaking an API in a beginner-facing platform carries an outsized cost: the beginner downloads existing example code, the compile fails, and the failure surfaces as cryptic C++ error messages that give no route forward; the dominant attraction of the platform is the volume of existing example code, which makes backwards compatibility of that code the property that matters most in any release.[80] An ATmega running continuously draws a few milliamps, which rules out coin-cell operation unless the whole system is designed around sleeping the processor.[226] A modular system defined at board level survives reuse poorly compared with one defined at schematic level, because a fixed board imposes a form factor, a part choice, a supply voltage and a power budget that will not suit the next design.[25]