At long last, the Arduino team has released Arduino 1.0 – an update to the development environment and core libraries that make the Arduino hardware do its thang. The 1.0 update has been in the works for a while, and covers a lot of changes, including some you’ll notice and some you won’t. How does all this affect your Arduino projects? Read on to find out.
This article doesn’t attempt to cover everything that’s different in the new release, just the things that will likely affect your existing code and your current workflow. Think of it as a migration guide. For information on all the major changes, check out the Arduino team’s official blog post or the release notes. You can also download the Arduino 1.0 release here.
Major changes: the Arduino 1.0 IDE
One of the first things you’ll notice is that the IDE looks different, with a new color scheme and updated icons for compilation and upload. Menu items have been changed in some cases, error messages have been updated, and there are a few new board types reflecting recent hardware releases (including the new ADK and Ethernet boards, which are mighty awesome additions if we do say so ourselves). You also get a progress bar when compiling or uploading, which is handy when you’re twiddling your thumbs and wondering if that massive sketch is ever going to finish transferring.
Major changes: the Arduino 1.0 core libraries
Overall, porting existing code to use the new IDE and libraries should be straightforward. However, there are a few changes you’ll want to look out for, particularly if you’re using the contributed libraries that come packaged with the core code. With the release of Arduino 1.0, the team stated that they were working to future-proof the code base, but they did so at the expense of 100% backwards-compatibility. Here’s a summary of the changes and what you can do to get your code working with the new platform:
println() now behave differently, as does any class derived from them (Serial, Ethernet, Wire, etc).
print(byte) will now print the digits of the byte value as ASCII characters, rather than printing the byte directly. This is more consistent with how it handles other numeric data types. In order to send a single byte, use the
write() class instead.
print() no longer supports the BYTE keyword, so you’ll want to make the same change anywhere you previously used it:
Write methods in Print-derived classes
If you have a class of your own that’s derived from Print, you’ll need to modify it’s
write method. Write now returns
size_t instead of
void, where the return value is the number of characters written. Make sure to change any mentions of
void write to
size_t write and handle the return appropriately.
In addition, be aware that Serial transmissions now occur asynchronously. This doesn’t necessarily require you to change any code, but there are situations you might want to. Anything using
Serial.print() or similar now is stored in a buffer that is transmitted in the background, allowing your serial communications to be completely non-blocking. This is great news! Previously, you could use the serial buffer to deal with incoming transmissions asynchronously, but now you can also send data and continue on to other tasks immediately, without waiting for the transmission to complete.
Changes to the Wire library
The Wire library also relies on the Stream class, and has been changed to be more consistent with similar classes. Instead of
you’ll need to use
Also, the write method now requires you to supply a type for any constant arguments. For example, if you previously used
you’ll now have to supply
The Ethernet library
A few things have been changed in the Ethernet library to make the code cleaner and to follow established conventions from other Arduino sources.
First, the client and server classes add an “Ethernet” prefix to avoid conflicts with other networking libraries. Also, you’ll need to initialize your client class first, then add connection parameters using the
connect() method. For example, change
Client client(server, 80); if(client.connect())
EthernetClient client; if(client.connect(server, 80)>0)
Note that we’re testing
client.connect() for values greater than zero because the method returns negative numbers to specify certain errors.
The server class has similar changes, with
Finally, just like the rest, the
UDP class adds a prefix to become
Using older Arduino libraries
If you’re using libraries that haven’t been updated to the 1.0 release, you’ll have to make some slight modifications to make them compatible. Libraries used to require a number of header file includes from the Arduino coure source code. Those includes have now been consolidated into a single Arduino.h header file.
You can simply take the old library and replace all of these headers:
#include "wiring.h" #include "WProgram.h" #include "WConstants.h" #include "pins_arduino.h"
However, if you want to maintain backwards compatibility, you’ll have to get a bit fancier. Using preprocessor conditionals, we can check the
ARDUINO version constant to see whether we’re using Arduino 1.0 or not. If so, we replace the original header files with the new one; otherwise, we leave them alone. Here’s the code to do that:
#if ARDUINO >= 100 #include "Arduino.h" #else #include "WProgram.h" #endif
Other interesting additions
Arduino 1.0 includes a few handy changes that don’t require you to modify your code, but might provide opportunities to be more efficient:
Mikal Hart’s SoftwareSerial is now a standard included library, which improves mightily on the old software serial functionality.
Serial and other classes that inherit from Stream now include new parsing functions for incoming data, originally from Michael Margolis’s TextFinder library. They include:
find(char *target); findUntil(char *target,char *term); parseInt(); parseFloat(); readBytes(buffer,length); readBytesUntil(term,buffer,length);
It’s also much easier to store strings to flash memory – just wrap any double-quoted string in
F() to save precious RAM. For example:
That wraps up the major items for now. Do you have any issues you’ve run into when upgrading to Arduino 1.0? Let us know in the comments.
You can also check out our recommendations for the Best Arduino Books to find more resources. We’ve mentioned which books in that guide are updated for the new release, and we’ll continue to update our descriptions as other authors make the switch.