Archive for the ‘Software’ Category

Showcase your project: ListComPorts per Windows

Friday, February 15th, 2013

Marco Lai ci propone un software da lui sviluppato per semplificare la gestione delle porte COM su di un sistema Windows, nel caso vengano utilizzate differenti schede Arduino in una volta sola:

Spesso mi capita di usare diversi tipi di Arduino collegati allo stesso pc e diventa abbastanza frustrante capire quale sia la relativa porta COM, dato che nell’IDE viene elencato il nome della porta senza la descrizione del tipo di dispositivo associato.
Quindi devo accedere a gestione dispositivi e controllare nella voce Port (COM e LPT) quale sia questa associazione, in modo da caricare gli sketch sui giusto relativi dispositivi.
Il problema poi aumenta quando collego e scollego le schede dalla porta usb, magari invertendo l’ordine sulle porte, ottenendo così nuovi assegnamenti di COM che mi costringono a tenere aperta la finestra gestione dispositivi.
Ho scritto una piccola utility che elenca le porte COM con la descrizione del dispositivo collegato, in questo modo lavoro meglio e quando ricollego le schede posso cliccare sul pulsante aggiorna per ottenere la nuova lista aggiornata.

Maggiori informazioni, così come il link per scaricare ListComPorts, possono essere trovate qui.

Arduino 1.0.2 released w/ support for the Micro, Wifi shield, and starter kit.

Thursday, November 8th, 2012

To accompany the new Arduino Micro, we’ve released a new version of the Arduino software, Arduino 1.0.2. This release also includes the WiFi library (for the WiFi Shield) and the examples for the Arduino Starter Kit. In addition, it contains many bug fixes and improvements, detailed in the release notes. In particular, it addresses many small incompatibilities between the Arduino Leonardo and other boards, which should ensure that the Micro also performs well (since it shares the same Atmel ATmega32U4 processor as the Leonardo).

You can download the software from the Arduino website.

Arduino 1.5: support for the Due and other processors, easier library installation, simplified board menu, etc.

Monday, October 22nd, 2012

The new Arduino 1.5 software brings a number of improvements, some in support of the new Arduino Due board and others to make it easier to install libraries and to simplify the boards menu. While these new features should work well, we expect to get lots of feedback and to iterate on them in future releases of the Arduino software. That also applies to the new (experimental) libraries for the Due, which add features like USB Host, audio playback, and cooperative scheduling. In the short-term, if you’re not using the Due, you might want to stick with the current 1.0.x (AVR-only) releases of the Arduino software; Arduino 1.0.2 will be out shortly. In the long-term, though, we’re going to be basing the Arduino software on the Arduino 1.5 code. Here’s an overview of the improvements and changes it contains.

Support for Multiple Microcontroller Architectures and Toolchains

While the interface for compiling and uploading sketches remains the same, we’ve made some significant changes under the hood in order to support the new 32-bit, Atmel SAM3X ARM processor on the Due. The new Arduino environment (IDE) can now be configured to target multiple processor architectures, each with its own toolchain and compilation process. To support a new processor family, the core language and libraries need to be ported (as we’ve done for the Due) and some configuration files edited to specify the commands for compilation and uploading. We’ve focused on ensuring that this new system works seamlessly for the Due and our existing AVR-based boards, but with some tweaks and improvements, we imagine that it will allow the Arduino environment to work with many, many more microcontrollers. We’ll be posting more details of this new system soon but, for now, you can look at the “avr” and “sam” directories in the Arduino software for an idea of how it works.

Note: the changes to the underlying configuration files means that older “third-party hardware” folders will require some tweaking to work with Arduino 1.5. We’ll try to improve backwards compatibility in future versions of the software but, for now, you’ll need to work with makers of third-party hardware to update their files for Arduino 1.5.

Easier Library Installation

Arduino 1.5 makes it easier to install libraries. We’ve added a new “Add Library…” menu item (inside of “Sketch > Import Library…”) that prompts you select a library zip file or folder on your computer. It then copies it to your sketchbook folder and adds it to the list of installed libraries. You can still install libraries manually but this is a simpler alternative.

Simplified Boards Menu

With the addition of the Due, the boards menu in the Arduino software was getting so long that we decided to simplify it. To do so, we’ve separated the choice of the board itself from that of the processor (microcontroller) on it. For example, if you’re using an Arduino Mega with an ATmega1280, select “Arduino Mega” from the boards menu and “ATmega1280” from the processor menu. To make things easier, the processor menu defaults to the microcontroller on the most recent version of the selected board. So if you have an Arduino Mega with an ATmega2560, you can simply select “Arduino Mega” from the boards menu and the processor menu will default to the appropriate item (“2560 or ADK”). If the selected board only has one processor option, the processor menu will be disabled. (For example, every Leonardo board comes with an ATmega32U4.) We hope this makes it a little easier to find and select the board you’re using.


We want to hear your feedback about Arduino 1.5 and its new features. For general suggestions and discussion, you can post on the Arduino forum. If you find a bug, please add it to the Google Code issues list. If you’d like to get more deeply involved in the development of the Arduino software, subscribe to the developers mailing list. We’re planning to iterate on the software and its features, so look for Arduino 1.5.1 and other releases to come soon.

Finally, I want to talk about the people who have made this release possible. Cristian Maglie has led the development of the Arduino 1.5 software and has done an incredible job. In the last few weeks, Cristian and I have been ably assisted by Federico Fissore, a Java developer also based in Italy who’s banged out a number of features. The multiple-platform code in Arduino 1.5 was initially based on work by Rick Anderson. And, again, the Due itself is the product of work by a number of additional people, as mentioned in our previous post about the board. Thanks to everyone!

leOS and looper: task scheduling made easy on Arduino

Wednesday, August 29th, 2012

In his website, Leonardo Miliani proposes a simple prototype of a pseudo operating system for Arduino, dubbed leOS (which is the acronym of little embedded operating system). Its goal is to provide the user with the capability to periodically schedule any given C function according to a specific time period. From his blog:

To be honest, it should more correct to say that leOS is actually something that is halfway a simple prototype of an real-time operating system (RTOS) and a scheduler. […]

leOS can run simple tasks that don’t require excessive CPU time but it can be useful in all of those situations where the user wants to let a task run itself out of the main loop.

Based on the experience pursued during the development of leOS, Leonardo also proposes another project, named looper, which resembles a simple task scheduler. Its goal is to provide a much lighter set of APIs for scheduling tasks on the microcontroller, if compared to leOS.

More information and source code can be found here, for leOS, and here, for looper.

[Via: Leonardo Miliani’s website]

Arduino 1.0.1 release includes Arduino Leonardo support and multiple translations.

Tuesday, May 22nd, 2012

I’m very happy to announce that Arduino 1.0.1 is now available on the software page. This release includes a ton of bug fixes and new features (see the release notes for details). The biggest additions are support for the Arduino Leonardo and translation of the Arduino development environment into multiple languages. We’ll be doing a blog post on the Leonardo soon but, for now, see its getting started page and hardware page.

The translations were the work of many people, particularly Shigeru Kanemoto (who internationalized the software and translated it into Japanese) and David Cuartielles from the Arduino team (who coordinated the translation process). Languages in Arduino 1.0.1: Arabic, Aragonese, Catalan, Chinese Simplified, Chinese Traditional, Danish, Dutch), English, Estonian, Filipino, French, Galician, German, Greek, Hindi, Hungarian, Indonesian, Italian, Japanese, Korean, Latvian, Lithuaninan, Marathi, Norwegian, Persian, Polish, Portuguese – Brazil, Portuguese – Portugal, Romanian, Russian, Spanish, Tamil. (For details or to help with the translations, see this page on the playground.)

Thanks to the many people who contributed to this release (see the release notes for credits). Again, you can download Arduino 1.0.1 from the software page.

Easy cross platform configurator for XBee modules

Thursday, March 8th, 2012

Italian company “moltosenso” has released a free, cross-platform software that allows you to configure all the parameters of your XBee modules. (more…)

Arduino 1.0 now available.

Wednesday, November 30th, 2011

Arduino 1.0 is now available from the download page.

A long time coming, this release brings small but important changes to clean up the Arduino environment and language – as well as adding lots of additional features. Updates to the environment include a new file extension, toolbar icons, and color scheme as well as a progress bar on compilation and upload. The language changes include modifications to the Serial class, addition of DHCP and DNS support to the Ethernet library, a new SoftwareSerial library, multi-file support in the SD library, modifications to the Wire library and UDP class, etc. For details, please see the release notes or this blog post. We’ll be pushing the updated reference for Arduino 1.0 live in the next day or two.

This release is the product of many people (listed in the release notes). Thank you to everyone who helped us get here!

Arduino 1.0 bringing improvements and changes.

Tuesday, October 4th, 2011

Arduino 1.0 is coming soon. The first release candidate was posted to our development site for Maker Faire NYC and is available for public download. It brings a number of improvements and changes to the software that we encourage you to test before the final Arduino 1.0 release, scheduled for the end of the month.

The Arduino development environment (IDE) has undergone a number of adjustments:

  • The file extension for sketches has changed from .pde to .ino, to avoid conflicts with the Processing software (“ino” are the last three letters in “Arduino”).
  • There are a new set of toolbar icons, including a checkmark icon to verify (compile) a sketch and an arrow for upload. The serial monitor icon has moved to the right of the toolbar. Also, shift-clicking the upload icon now uploads using a programmer (selected in the Tools menu). You can still enable verbose output in the preferences dialog. (Icons were designed by Nicholas Zambetti.)
  • There’s a new color scheme and about image for the IDE (by
  • The name of the currently selected board and serial port are now shown at the bottom of the editor. (Code from Wiring.)
  • A progress bar is displayed during compilation and upload. (Code from Wiring.)

The changes of perhaps larger practical impact, though, are those to the Arduino language. Here are some of the bigger changes:

  • Serial transmission is now asynchronous – that is, calls to Serial.print(), etc. add data to an outgoing buffer which is transmitted in the background. Also, the Serial.flush() command has been repurposed to wait for outgoing data to be transmitted, rather than dropping received incoming data.
  • The behavior of Serial.print() on a byte has been changed to align it with the other numeric data types. In particular, it will now print the digits of its argument as separate ASCII digits (e.g. ‘1’, ‘2’, ‘3’) rather than a single byte. The BYTE keyword has been removed. To send a single byte of data, use Serial.write() (which is present in Arduino 0022 as well).
  • The Serial class (as well as other classes inheriting from Stream, like EthernetClient, SoftwareSerial, Wire and more) now contains functions for parsing incoming data, based on the TextFinder library by Michael Margolis. They include find() and findUntil() to search for data, parseInt() and parseFloat() for converting incoming characters into numeric values, and readBytes() and readBytesUntil() for reading multiple bytes into a buffer. They use a timeout that can be set with the new setTimeout().
  • The SoftwareSerial class has been reimplemented, using the code originally written for the NewSoftSerial library by Mikal Hart. This allows for multiple simultaneous instances, although only one can receive at a time.
  • Support has been added for printing strings stored in flash (program memory) rather than RAM. Wrap double-quoted strings in F() to indicate that they should be stored in flash, e.g. F(“hello world”).
  • The String class has been reimplemented as well, by Paul Stoffregen. This new version is more memory-efficient and robust. Some functions which previously returned new string instances (e.g. trim() and toUpperCase()) have been changed to instead modify strings in place.
  • Support for DHCP and DNS has been added to the Ethernet library, thanks to integration by Adrian McEwen. Most classes in the Ethernet library have been renamed to add a “Ethernet” prefix and avoid conflicts with other networking libraries. In particular, “Client” is now “EthernetClient”, “Server” is “EthernetServer”, and “UDP” is “EthernetUDP”. A new IPAddress class makes it easier to manipulate those values.
  • The UDP API has been changed to be more similar to other libraries. Outgoing packets are now constructed using calls to the standard write(), print(), and println() functions – bracketed by beginPacket() and endPacket(). The parsePacket() function checks for and parses an incoming packet, which can then be read using available(), read(), and peek(). The remoteIP() and remotePort() functions provide information about the packet’s origin. (Again, thanks to Adrian McEwen for the implementation.)
  • The Wire library has also been modified to use the standard read() and write() functions instead of send() and receive(). You can also use print() and println() for outgoing data.
  • The SD library now supports multiple simultaneous open files. It also provides the isDirectory(), openNextFile(), and rewindDirectory() functions for iterating through all the files in a directory. (Thanks to Limor Fried.)
  • There are some other small additions that will be documented in the reference updates for Arduino 1.0.

Finally, a few other notes of particular concern to those developing libraries or otherwise interested in the internals of the Arduino software:

  • The WProgram.h file, which provides declarations for the Arduino API, has been renamed to Arduino.h. To create a library that will work in both Arduino 0022 and Arduino 1.0, you can use an #ifdef that checks for the ARDUINO constant, which was 22 and is now 100.
  • The write(), print(), and println() functions in Stream now return a size_t (instead of void). This indicates the number of bytes actually written by the function. Any classes that inherit from Stream will need to change accordingly. Additionally the write(str) function has been given a concrete implementation – it calls write(buf, len) – so sub-classes don’t need to (and shouldn’t) implement it.
  • There are new abstract base-classes for Client, Server, and UDP to provide portability across networking libraries.
  • The pin definitions for the Arduino boards (i.e. the mappings from pin numbers to port register / bit pairs) is now stored in a sub-folder of a new variants/ folder in the hardware folder. The variant to use for a given board is specified by the preference in the boards.txt file.
  • The new, variant-specific pins_arduino.h files now provides additional macros with information about the characteristics of the board (e.g. the locations of the SPI and TWI pins, and the number of digital and analog pins).
  • The avrdude included with the Mac and Windows versions of the Arduino software has been upgraded to avrdude 5.11 (from an Arduino-specific version of avrdude 5.4). The software now uses the “arduino” programmer type in place of “stk500v1” for uploading to most Arduino boards.

Please try out the release candidate and give us feedback. If you find a bug or a specific issue that needs addressing, please open a new issue on the Google Code issue list. For more general discussion, see the developers mailing list or the suggestions forum.

If you develop an Arduino library, we encourage you to try it out with the Arduino 1.0 release candidate, as you’re likely to find some things that will stop it from compiling. The fixes should be straightforward, so please open an issue or contact the developers list if you have any problems.

Again, we’re hoping to do the final Arduino 1.0 release at the end of the month, so there’s not much time to do fixes or make further changes. Your help and understanding is greatly appreciated. And, don’t worry, there are plenty more versions of the Arduino software to come!

Samsa II, The Hexapod

Tuesday, March 29th, 2011

[pabloxid] shared an Hexapod project on the forum based on an Arduino MEGA 1280 and 18 Dynamixel AX-12 motors:

SAMSA is based on the Wiring board, with an ATmega128 microcontroller, and SAMSA II on the Arduino Mega, with an ATmega1280. Both are pretty similar, tough the ATmega1280 has 8 KB SRAM, twice the ATmega128. For SAMSA II the Arduino IDE was not used. The software was written directly in C++, using some libraries from both Arduino and Wiring.

SAMSA II has also two additional microcontrollers. One is an old Arduino Mini (ATmega168) located in the head, tasked with handling the sensors. The other is an ATmega8 and is integrated in the display. The firmware in the display was replaced with another one, freeing the main microcontroller from handling the display pixel by pixel, storing the frame buffer, etc.

The head’s microcontroller is responsible for sampling, filtering and processing sensor’s data. The data from the Sharp distance sensor and the lateral IR sensors are combined in a single “super smart distance sensor”. This microcontroller also decodes the data coming from the 38 KHz IR receiver, used for the Remote Control.

These two additional microcontrollers further reduce the load on the main microcontroller, allowing for more sophisticated behaviours.


Fix to Uno and Mega 2560 Linux serial problems

Tuesday, February 15th, 2011

We’ve just posted a tutorial on upgrading the firmware on the ATmega8U2 on the Arduino Uno and Mega 2560. This should resolve the problems that some of you have had with serial communication between those boards and Linux. The upgrade doesn’t require a programmer or other hardware, just adding a resistor to the board and touching a couple of pins together. It’s a safe process, and if it doesn’t work the first time you can do it again.

We’re in the process of testing the new firmwares on other operating systems so that we can begin to ship them as the default on new boards. So far, though, many Linux users have had success with the upgraded firmwares.

Thanks to Dean Camera (author of LUFA) for his help in fixing the firmware.