The holidays are over and we’re back at work, so it’s time to clean up the house. To get ready for autumn, our amazing dev team has decided to devote an entire week to resolve as many of the open issues on the Arduino IDE repository and related projects (cores, libraries, etc.) as possible.

Starting this Monday, the dev team will be going through the open issue log — analyzing requests, fixing them where immediately possible, and in some cases, reaching out to the original submitter to establish if they are still seeing an issue or if it can be closed out. If you do receive such a notification in your GitHub account (with a subject starting with [arduino/Arduino] …), please help us help you by responding accordingly.

Big thanks to all of you who’ve contributed in the past and continue to submit the issues you find within the Arduino IDE for resolution. We appreciate your support and acknowledge your patience while waiting for them to be fixed.

Let’s watch that open issue counter fall by the day!

Back in the olden days, when the Wire library still sucked, the Arduino was just a microcontroller. Now, we have single board computers and cheap microcontrollers with WiFi built in. As always, there’s a need to make programming and embedded development more accessible and more widely supported among the hundreds of devices available today.

At the Embedded Linux Conference this week, [Massimo Banzi] announced the beginning of what will be Arduino’s answer to the cloud, online IDEs, and a vast ecosystem of connected devices. It’s Arduino Create, an online IDE that allows anyone to develop embedded projects and manage them remotely.

As demonstrated in [Massimo]’s keynote, the core idea of Arduino Create is to put a connected device on the Internet and allow over-the-air updates and development. As this is Arduino, the volumes of libraries available for hundreds of different platforms are leveraged to make this possible. Right now, a wide variety of boards are supported, including the Raspberry Pi, BeagleBone, and several Intel IoT boards.

The focus of this development is platform-agnostic and focuses nearly entirely on ease of use and interoperability. This is a marked change from the Arduino of five years ago; there was a time when the Arduino was an ATmega328p, and that’s about it. A few years later, you could put Arduino sketches on an ATtiny85. A lot has changed since then. We got the Raspberry Pi, we got Intel stepping into the waters of IoT devices, we got a million boards based on smartphone SoCs, and Intel got out of the IoT market.

While others companies and organizations have already made inroads into an online IDE for Raspberry Pis and other single board computers, namely the Adafruit webIDE and Codebender, this is a welcome change that already has the support of the Arduino organization.

You can check out [Massimo]’s keynote below.

We’re excited to announce a new update to the Arduino Create web platform, which will enable fast and easy development and deployment of IoT applications with integrated cloud services on Linux-based devices.

What this means is that users will be able to program their Linux boards as if they were regular Arduinos. Multiple Arduino programs can run simultaneously on a Linux board and programs can communicate with each other leveraging the capabilities of the new open source Arduino Connector. 

Arduino Create Cloud now allows users to manage individual IoT devices, and configure them remotely and independently from where they are located. To further simplify the user journey, we’ve also developed a novel “out of the box” experience that will let anyone set up a new device from scratch via the cloud without any previous knowledge by following an intuitive web-based wizard

The initial release has been sponsored by Intel® and supports X86/X86_64 boards. As a reference implementation, a simplified user experience has been designed for the AAEON® UP² board, although other platforms are already supported by the Arduino Create Cloud platform, such as the Intel® NUC, Dell Wyse®, Gigabyte™ GB-BXT.

In the coming months, we plan to expand support for Linux–based IoT devices running on other hardware architectures. Until then, you can find more information here and follow the tutorials below to help get you going:

• Getting Started with Intel-Based Platforms on Arduino Create
• Interacting with a TI SensorTag from an Intel NUC
• Intel Math Kernel Library on Arduino
• Arduino ? Linux (on UP2 Board) with Intel Mraa

Today we’re very excited (and a bit nervous) to announce the new development cycle of the Arduino IDE.

As you may have noticed, we’ve been continuously removing functionality from the Java package, and migrating them to a collection of external tools. We began this project by moving the build logic to arduino-builder, which now also powers the Arduino Create infrastructure.

We think that this split will keep the tools manageable, while giving a chance for third parties to integrate them into their products without the burden of a full-blown IDE.

Moreover, we are introducing another couple of tools:

One is arduino-cli, which we’ll uncover in the next few weeks as soon it comes out of pre-pre-alpha stage.

The other is arduino-preprocessor, which supersedes ctags in the sketch preprocessing phase. Moving to a different tool has been a necessary step for many reasons, the most important being the ctags’ limited parsing of complex C++ sketches.

arduino-preprocessor is based on libclang, statically compiled for zero dependencies execution; it uses clang’s superpowers to extract the prototypes we need, directly from the AST. As a (really nice) side effect, this engine can even be used for context-aware completion, probably the most required feature from the beginning of Arduino.

Since we’re unveiling such a big feature, it will surely impact the overall performance. To avoid keeping it out-of-tree for too long, we decided to open the beta branch.

This branch will be a playground for new ideas and implementations, including more collaborators with push powers. The branch has just been populated with all the IDE-related pull requests scheduled for the next release.

The beta branch is quite peculiar as well, because precompiled binaries generated from this branch will be available directly from the arduino.cc download page. We noticed that nightly (or hourly) builds are insufficient to spot a whole class of bugs, which may harm non-developers, users with non-latin charsets, and so on.

Being marked as experimental, the beta branch will not be ready for large-scale deployment (although it will probably be okay for everyday use); thus, we won’t provide a Windows exe or a signed OSX app. However, we hope that many people will test it and report bugs and impressions, so we can merge it safely into master in the near future.

A short curated list of the beta branch’s improvements over the latest 1.8.x IDE:

• Initial support for autocompletion (activate it using CTRL+space)
  • Attention: Launching for the first time is quite slow and will freeze the UI. Don’t worry, simply wait for it to unstick.
• Initial work on daemonized builder (using file watchers, will be able to spot if compilation can be avoided, partially or totally).
• AVR core has been moved to its own repo.
• Tabs are scrollable. 🙂
• The serial monitor is html-aware and clickable (if steady).
• Initial work on Library dependencies UI.
• Initial work on Hi-DPI support on Linux.
• Find/replace window is always on top of its own editor window.
• Library/Board manager show buttons on mouseover.

In case you haven’t noticed, our team has just released Arduino IDE 1.8.5! This time the changelog is fairly small, as it mainly solves a (rather important) problem being encountered by macOS users who just updated to High Sierra (10.13).

If you are not using English as system language, any version of Arduino you launch will lack the menu in the system bar. Every Java application is experiencing the same problem, so it will probably be solved by Apple in the near future.

In the meantime, IDE 1.8.5 recognizes when the menu bar is not being displayed and replaces it with a Windows-style one. It may not be the prettiest thing, but at least it works!

If you want to recover the old menu bar while keeping the whole system in your normal language, you can issue a single command on Terminal:

defaults write cc.arduino.Arduino AppleLanguages '(en)'

Thank @AdrianBuza for the workaround. Issuing this command will make Arduino IDE in English, however you can still change the language under “Preferences” without losing the macOS integration.

Arduino Create is now available to everyone on Chrome OS devices, with $0.99 per month subscription. An Arduino account and Google ID is all you need to use it, just follow the Create Getting Started guide on your Chrome OS device. We are actively working on specific licensing and pricing for schools, so stay tuned.

The new Arduino Create Chrome App enables students and other users to write code, access tutorials, configure boards, and share projects. Designed to provide a continuous workflow from inspiration to implementation, Makers can easily manage every aspect of their project right from a single dashboard.

Developed with the classroom in mind: The Arduino Chrome App allows you to teach and tinker with Arduino electronics and programming in a collaborative, always-up-to-date environment.

Built for Chrome OS: Code online, save your sketches in the cloud, and upload them to any Arduino connected to your Chrome OS device, without having to install anything locally. All the contributed libraries are automatically included.

The following Arduinos are currently supported: Uno, 101, Mega, Esplora, Nano (ATmega328), Micro, Zero, MKR1000, MKR Zero, MKR Fox 1200, Pro and Pro Mini (ATmega328). We are actively working with the Chromium team to restore support for the Arduino Leonardo in a future Chrome OS release.

The launch of this app would not have been possible without the following open source components:

• avrgirl-arduino by Suz Hinton
• dapjs by Microsoft,
• browser-serialport by Glen Arrowsmith
• browser-usb by Jacob Rosenthal

As usual if you encounter any bugs, issues, or have an idea on how we can improve the Chrome app, please open a discussion thread on this Forum page.
Please note that this app will work only on Chrome OS, if you click on the Google Store link on any other OS you will not be able to install it.

If you were sad that Codebender had bit the dust, cheer up. A site called codeanywhere has acquired the online Arduino development environment and brought it back to life. In addition to the main Codebender site, the edu and blocks sites are also back on the air.

Not only is this great news, but it also makes sense. The codeanywhere site is a development IDE in the cloud for many different programming languages. The downside? Well, all the people who said they’d be glad to pay to keep Codebender alive will get a chance to put their money where their mouth is.

Here’s an excerpt from Codebender’s blog:

First of all, codebender will mostly remain the same. It will continue to operate as a standalone service, so you don’t have to change the way you are currently using codebender. However, it will transition to a monthly subscription service. This means that you will be able to use it for free for 1 month (as a trial, beginning on June 1st, or for the first month after registration), and it will then cost $10/month to keep using it. This is the price to pay for keeping codebender alive and sustainable, and it’s a small one, really.

Secondly, Codeanywhere intends to keep adding more and more features, the same way we have been adding features, libraries, and board support in the past few years. So you can expect codebender to keep improving with time, much as it did until now.

We have to wonder how many people will pay $120 / year to do something they can do for free. Mbed has support from ARM and offers a free IDE. Maybe a better deal with Codebender would have been with Atmel or Arduino. Not that we are opposed to charging for services, but we imagine a lot of people will just use free tools unless they have a strong use case for using a cloud-based service.

We covered Codebender’s short-lived demise back in October of last year.

In a recent post, I talked about using the “Blue Pill” STM32 module with the Arduino IDE. I’m not a big fan of the Arduino IDE, but I will admit it is simple to use which makes it good for simple things.

I’m not a big fan of integrated development environments (IDE), in general. I’ve used plenty of them, especially when they are tightly tied to the tool I’m trying to use at the time. But when I’m not doing anything special, I tend to just write my code in emacs. Thinking about it, I suppose I really don’t mind an IDE if it has tools that actually help me. But if it is just a text editor and launches a few commands, I can do that from emacs or another editor of my choice. The chances that your favorite IDE is going to have as much editing capability and customization as emacs are close to zero. Even if you don’t like emacs, why learn another editor if there isn’t a clear benefit in doing so?

There are ways, of course, to use other tools with the Arduino and other frameworks and I decided to start looking at them. After all, how hard can it be to build Arduino code? If you want to jump straight to the punch line, you can check out the video, below.

Turns Out…

It turns out, the Arduino IDE does a lot more than providing a bare-bones editor and launching a few command line tools. It also manages a very convoluted build process. The build process joins a lot of your files together, adds headers based on what it thinks you are doing, and generally compiles one big file, unless you’ve expressly included .cpp or .c files in your build.

That means just copying your normal Arduino code (I hate to say sketch) doesn’t give you anything you can build with a normal compiler. While there are plenty of makefile-based solutions, there’s also a tool called PlatformIO that purports to be a general-purpose solution for building on lots of embedded platforms, including Arduino.

About PlatformIO

Although PlatformIO claims to be an IDE, it really is a plugin for the open source Atom editor. However, it also has plugins for a lot of other IDEs. Interestingly enough, it even supports emacs. I know not everyone appreciates emacs, so I decided to investigate some of the other options. I’m not talking about VIM, either.

I wound up experimenting with two IDEs: Atom and Microsoft Visual Studio Code. Since PlatformIO has their 2.0 version in preview, I decided to try it. You might be surprised that I’m using Microsoft’s Code tool. Surprisingly, it runs on Linux and supports many things through plugins, including an Arduino module and, of course, PlatformIO. It is even available as source under an MIT license. The two editors actually look a lot alike, as you can see.

PlatformIO supports a staggering number of boards ranging from Arduino to ESP82666 to mBed boards to Raspberry Pi. It also supports different frameworks and IDEs. If you are like me and just like to be at the command line, you can use PlatformIO Core which is command line-driven.

In fact, that’s one of the things you first notice about PlatformIO is that it can’t decide if it is a GUI tool or a command line tool. I suspect some of that is in the IDE choice, too. For example, with Code, you have to run the projection initialization tool in a shell prompt. Granted, you can open a shell inside Code, but it is still a command line. Even on the PlatformIO IDE (actually, Atom), changing the Blue Pill framework from Arduino to mBed requires opening an INI file and changing it. Setting the upload path for an FRDM-KL46 required the same sort of change.

Is it Easy?

Don’t get me wrong. I personally don’t mind editing a file or issuing a command from a prompt. However, it seems like this kind of tool will mostly appeal to someone who does. I like that the command line tools exist. But it does make it seem odd when some changes are done in a GUI and some are done from the command line.

That’s fixable, of course. However, I do have another complaint that I feel bad for voicing because I don’t have a better solution. PlatformIO does too much. In theory, that’s the strength of it. I can write my code and not care how the mBed libraries or written or the Arduino tools munge my source code. I don’t even have to set up a tool chain because PlatformIO downloads everything I need the first time I use it.

When that works it is really great. The problem is when it doesn’t. For example, on the older version of PlatformIO, I had trouble getting the mBed libraries to build for a different target. I dug around and found the issue but it wasn’t easy. Had I built the toolchain and been in control of the process, I would have known better how to troubleshoot.

In the end, too, you will have to troubleshoot. PlatformIO aims at moving targets. Every time the Arduino IDE or the mBed frameworks or anything else changes, there is a good chance it will break something. When it does, you are going to have to work to fix it until the developers fix it for you. If you can do that, it is a cost in time. But I suspect the people who will be most interested in PlatformIO will be least able to fix it when it breaks.

Bottom Line

If you want to experiment with a different way of building programs — and more importantly, a single way to create and build — you should give PlatformIO a spin. When it works, it works well. Here are a few links to get you started:

• The PlatformIO IDE (requires Atom)
• PlatformIO Core (not needed if you install an IDE package)
• Visual Studio Code (install PlatformIO from within the IDE)

Bottom line, when it works, it works great. When it doesn’t it is painful. Should you use it? It is handy, there’s no doubt about that. The integration with Code is pretty minimal. The Atom integration — while not perfect — is much more seamless. However, if you learn to use the command line tools, it almost doesn’t matter. Use whatever editor you like, and I do like that. If you do use it, just hope it doesn’t break and maybe have a backup plan if it does.