The Next Generation of High-Powered Microcontrollers


When you start working with physical computing the first thing pretty much everybody does is to blink an LED on, and off, again. When things were harder, this was a rite of passage. Just to get to the stage where you could turn an LED on, and then off again, could take a week or more of hard work. The arrival of the Arduino changed all that, relegating it to a simple parlour trick, a “Hello World” of hardware.

These days things are different, and while we’re reaching the end of Moore’s Law, we haven’t quite got there yet. Over the last few years we’ve seen a bewildering explosion in the number of microcontroller and single board computers. People have experimented with form factors and processors, and pretty much every board now comes with radios, sometimes lots of radios.

Despite this proliferation, at least for now, the maker market for computing hardware sits on top of three, somewhat unequally balanced, legs. In one corner, despite all the recent legal troubles, is the now venerable Arduino and a large number of compatibles and spin-offs, in the other is Raspberry Pi. The third leg, perhaps more arguably, consists of boards based around the ESP8266 and ESP32. Not a single company this time, but a community. Because what these three pillars of the community share is just that, community. About and around them are active, vibrant, communities.

Over the years I’ve been excitedly told about the next Arduino or Raspberry Pi killer more times than I can recall. I’ve now even been pointed at an ESP8266 killer once or twice. One may come along, but nothing has ever come of it to date. It’s not because the boards I’m shown are bad boards, or that they aren’t price competitive, although sometimes they just aren’t, but because it’s hard to build large communities, and there has to be a reason for an existing community to move on. It appears that “good enough” is sometimes all that’s needed.

However, it is very clear that the current state of the board market is in transition. Just as the way we’re using computers is changing, the way we build hardware is changing with it. Because of that, manufacturers aren’t entirely sure how people are going to use their product. Like our other computers, microcontroller boards have become communication tools. It’s just that, at least for the most part, they’re talking to each other, rather than to us.

At the moment, we’re seeing both a collapse in the number of form factors, and what feels like a sea-change in the languages and methodology to program the boards we’re using. After the many experiments we’ve seen over the last half decade, there is now little question that the Raspberry Pi has become the defacto standard form factor in the single board computer market. While in the micro-controller market things are a little bit more complicated, with Arduino in the process of abandoning their “classic” form factor that has for some years been the standard in favour of something more modern, the community seems to be adopting Adafruit’s own Feather as the next standard. Spanning both the Arduino community, and the community that has grown up around the two new Espressif chips, the Feather form factor has brought multiple chipsets, and snap on attachments known as “FeatherWings,” under a single roof which makes a lot of sense.

The Adafruit Feather.

Because, perhaps the most interesting thing going on in the micro-controller market right now has little to do with the hardware, it is hardware agnostic. Instead it’s all about how we build, rather than what we build with.

When it arrived, the Arduino was a massive disruption to the existing microcontroller ecosystem. However the disruption it brought was only partially to do with the hardware, and far more to do with the development environment that came with it. The success of the board spawned any number of clones and counterfeits. However, it was the existence of derivatives that was by far more interesting. People experimented with features, but reassuringly the boards themselves could be used inside the familiar Arduino development environment. Arguably it might well have been the addition of “official” third-party board support, that drove some of the adoption of the ESP8266 in the early days.

However things have moved on, while the Arduino development environment was a revolution when it was introduced, and scathingly criticised for making things “too easy,”  it now seems dated. While the online Arduino Create environment—destined to replace the traditional desktop application—has come a long way since it came out of beta a couple of years ago, it’s still at its heart the same Arduino-like experience (and closed to non-Arduino boards). For a new generation of developers, used to Javascript and Python, that’s a problem.

A whole generation of programmers have now grown up with the web, where Javascript is the defacto language. Alongside them is another, even larger, group who have made Python the defacto language of science, engineering, data analysis, and most recently machine learning. The idea that you need to learn C to program hardware seems antiquated. Almost as antiquated as the idea that you should learn assembler, an idea the Arduino itself was pivotal in killing off in turn.

While the growth of high-level languages on microcontrollers has been slow, I started talking about Javascript on microcontrollers and a possible “third community” well before the ESP-based boards became that community. Over the last year or two we’ve what I can only describe as a watershed moment in the microcontroller world, interpreted languages like Javascript and Python have become the new normal.

“Seasoned Embedded C developers may not be convinced, but it’s not about them. It’s about opening up microcontroller development to the millions of JavaScript developers out there.”—Gordon Williams, Director, Espruino

Evidence of this can be seen in the community that has formed around the ESP-based chipsets. While the chip’s Arduino compatibility is a selling point, the community-built Lua development environment is actually far more widely used.

“If you factor software development time into the cost of your product (which you should), it’s going to be cheaper to use an interpreted language in a lot of cases.”—Gordon Williams, Director, Espruino

The emerging future communities we’re seeing being built are not around specific chipsets or even boards, but around languages. Real high level, widely used, languages like Python and Javascript. By cannibalising the existing Arduino community, and even the newer community formed around the ESP-based boards, the new microcontroller communities are hardware agnostic. They care far more about language support than that chipset the board is built around. You have to wonder if this new trend is something that is partially driving the success of the Feather form-factor, which is more-or-less chip agnostic.

The Adafruit Gemma M0 was the first board to run Circuit Python out of the box, with a host of others following including Metro M0 Express, Metro M4, Feather M0 Express and a soon to be released Feather M4. High-level language support is fundamentally disruptive to the the way we currently build hardware.

CircuitPython

Traditionally developing firmware for hardware has taken infrastructure, sometimes a lot of infrastructure. Back before the Arduino came along, you needed to buy a—usually fairly expensive—development board from the manufacturer, install a proprietary development environment, write your firmware, and then finally buy individual chips and roll your own PCBs. The Arduino fixed that, but what it didn’t fix was the necessity to install software, drivers, and hack away in a language that, to most developers, is foreign.

Now when you plug it in a board running CircuitPython it will simply show up on your desktop as a external drive. Edit the code.py file on the drive, in whatever text editor you want to use, and changes to your code are run as soon as the file is done saving. No installation, no compilers, no proprietary development environments. You can write your code on Windows, macOS, linux, or even on a ChromeBook.  It doesn’t matter anymore, and that’s what makes it powerful.

Most people, and most makers, want to solve a problem. While, for some, the specifications of the board really matter, those people are by far the minority. In a move that mirrors the changes we saw in the desktop and laptop computer market, our microcontroller hardware has become “good enough” that we now don’t have to worry about the underlying technology.

Your solution to a problem could be powered by Python, Javascript, Arduino, or magic beans. It doesn’t matter. The important thing is whether it solves the problem better than other methods, more seamlessly, and without the need for the end user to understand whatever technology you’ve used. Or in the case of developers, without having to delve deeper into the infrastructure that you have to, writing code is a way to solve problems, not an end in itself.

If high level languages bring more accessibility to people that want to make use technology, we as hardware developers should welcome it, promote it, and above all don’t look down on the people using it.

Because there’s more disruption to come. The last year or so has seen a coming of age for the FPGA. Which, even more than microcontrollers, have suffered from an infrastructure and usability problem. Stuck in a ‘pre-Arduino’ age, the FPGA has languished while microcontrollers have become far more usable, and accessible to non-specialist developers.

Appearing somewhat lost after their legal troubles you have to wonder whether Arduino might manage to do it again and reinvent themselves, integrating  FPGAs into the standard Arduino toolchain and turn configuring an FPGA using Verilog into yet another “Hello World” of hardware. While their new Arduino MKR Vidor 4000 may do this, it has yet to been seen whether Arduino Create can make programming the FPGA easy. This move, though, actually appears to be moving Arduino away from its open source roots. There is no open source toolchain for the Intel Cyclone FPGA that they’ve used in their new board.

When it comes down to it, I actually think that the next generation of high powered micro-controllers will be defined, not by their hardware, but by their user experience. Programmed using an easily accessible, and widely known, high level language like Python, and perhaps configured under-the-hood using yet to be written tools that make using an FPGA as easy as today’s microcontrollers. The future of hardware is about accessibility.

That’s a big change for the traditional community to swallow, perhaps bigger than the move back in the day away from assembler, to programming chips in a “high level” language like C. But there are far more of “them,” than there are of “us.” Far more Python and Javascript programmers, than those of us familiar with low-level hardware. Far more people that care about solving a problem, than care about the technology that solves it.


via Adafruit

Thoughts or comments?