Why Your Dev Board Won’t Catch On: A Retrospective of Arduino’s Popularity

In recent years, I have seen a glut of “maker” development boards enter the market promising to be the next Arduino. Chip manufacturers, hobby-focused companies, and enterprising individuals caught wind of the “maker movement” 5-10 years ago and have been trying to capitalize on it ever since (some more successful than others).

Here’s the catch: just because you slap your latest microcontroller on a slick-looking PCB does NOT mean it will catch on.?

Let’s take a moment to review what makes the Arduino work. For now, I’m going to dissect the Arduino UNO, but know that this applies to many other Arduino variants on the market.

Programming Arduino is the same as programming a microcontroller, as the Arduino board contains a microcontroller that you're uploading programs to. There are a few things that Arduino does that make the whole process easier:

Hardware: official and unofficial "Arduino" boards (like the UNO) have all of the necessary components you need to run the microcontroller, such as a power supply, decoupling capacitors, USB-to-Serial translator chip, etc. As a result, you don't have to build all of this by hand on a breadboard or custom PCB.?

Almost every Arduino board is open source, which means you can find its schematic and PCB layout files (or at least PDF versions). As a result, engineers have a starting point for future designs.

Many people assume that Arduino is just the hardware, but it goes way beyond that.

Bootloader: The onboard ATmega328p microcontroller runs a special program every time it boots up (i.e. restart or receives power) called a "bootloader." This bootloader comes pre-packaged with the Arduino and on boot, it briefly looks for data on the serial port. If you send it special commands, it will then record that information onto its flash memory to run as a program on next boot. If it does not receive those special commands, it simply runs whatever program it finds in the flash memory. The bootloader allows you to send programs over serial rather than needing a special "programmer" hardware, which traditionally costs $50+ (there are hacked ones that are much cheaper. In fact, you can turn your Arduino UNO into a programmer to program other Arduino UNOs).

Simple IDE: The Arduino software (IDE) tries to be as simple as possible to avoid clutter and confusing you with hundreds of options often found in professional IDEs. You lose out on a lot of features (e.g. code completion, step-through debugging, etc.), but it means you can write simple programs quickly and then compile and upload them to the Arduino with a single button click. The IDE also comes pre-loaded with the necessary toolchain to build programs for your target IDE along with a package/library manager that makes it easy to add other boards (and their associated toolchains).

Default, abstracted libraries: Arduino does its best to make writing programs for any supported board/chip as easy as possible. For example, there is a lot going on that you don't see when you write something like?digitalWrite(3, HIGH);. The function "digitalWrite" is an abstract function that hides the low-level details of writing to several registers on the target microcontroller. Without Arduino, you would need to write code that is specific to your particular microcontroller. For example, here is what blinky looks like on an ATmega328p:

#define F_CPU 16000000UL

#include <avr/io.h>

#include <util/delay.h>

?

int main(void)

{

???DDRB |= (1<<DDB1);

???while (1)

???{

	PORTB |= (1<<PORTB1);

	_delay_ms(1000);

	PORTB &= ~ (1<<PORTB1);

	_delay_ms(1000);

???}

}        

The DDRB and PORTB variables are specific registers on the 328p as defined in the avr/io.h file. This code would not run on a SAMD51 or ESP8266, as those registers and configuration processes are very different. However, the Arduino libraries abstract this away for us such that:

setup() {

?pinMode(13, OUTPUT);

}

?

loop() {

?digitalWrite(13, HIGH);

?delay(1000);

?digitalWrite(13, LOW);

?delay(1000);

}        

runs on a variety of microcontrollers, assuming that "pin 13" is mapped to one of the pins on the supported board. The downside of this abstraction is that you lose some efficiency, as a call to digitalWrite() might call several other functions to ensure that it's toggling the right register bits on the right microcontroller. It also might set the mode register bits every time, and you don't have control of that. So, your program might run a little slower and take up more memory as a result.

?Community: The Arduino project?started as a Master’s thesis in 2003, and it took over 10 years to reach peak popularity. The plot below shows the Google search trends for “Arduino” since 2004.

Arduino came at a perfect time: programming a microcontroller in 2004 was an arduous process. Simply getting an LED to blink might be an entire work day of fighting with drivers, documentation, and IDE installations. Sure, Arduino may not be the most efficient or robust way to program and debug a microcontroller, but the market certainly demonstrated a need for ease-of-use.

Over time, communities formed to help each other use the board and software. This included forums, tutorials, and user-created libraries. A few engineers could never hope to create this amount of content.

To be successful, Arduino required a critical mass of users helping each other. Social media and sites like Instructables also arrived at an opportune time to make sharing projects easier.

Price Point: ATmega 168- and 328p-based Arduino boards sold in the $20-30 range, which undercut the popular development boards at the time (which often sold for $50+), such as the BASIC Stamp and the Atmel STK500.?

Due to a flood of new development boards in recent years and easier/cheaper manufacturing, similar boards can be found in the $5 price range these days. Undercutting the market is now a difficult proposition.

So where does that leave us? Creating the “next Arduino” will be difficult. You need to take all of the factors listed above into account, not just the hardware. Remember that Arduino is much more than just a microcontroller on a PCB.

Even some official Arduino boards fail to catch on (e.g. Portenta, Vidor) due to missing the mark on some of these factors. Sometimes, there is simply not a big enough market for such platforms.

Languages like MicroPython and CircuitPython excite me, as they offer easy ramps to using microcontrollers, especially for those coming from the software world where Python is a popular language. They don’t necessarily solve the issue of cheap dev boards, but the communities do seem to be growing.

Focusing on ease-of-use (despite any losses in efficiencies) is a key takeaway from the above factors. As an engineer, if I can’t understand your API and get an LED blinking in a couple of hours, I’m likely going to look elsewhere (unless, for some reason, I’m forced to use your platform).

That being said, some dev boards offer a unique set of features (e.g. WiFi, Bluetooth, camera) that can override things like price point and ease-of-use. The ESP32 and OpenMV can be on the pricier side, but they offer features not found on other boards. If you can't beat the market on the factors listed, you need to provide something unique.

If you are a distributor, be wary of any manufacturer pitching a pretty dev board. If they don’t have a solid software API, good documentation, an easy-to-use IDE (or something that plugs into a known good IDE, like VS Code), and a growing community, it likely won’t be the “next Arduino.”