Arduino and Android devices: the (not so) well known USB connection

Hi boyz and girlz (with the “worm” of embedded development inside! 🙂 ).

This time I would like to talk about a new topic (following an input from SirsLab of University of Siena), tied to the connection via USB between Android phones (or tablets) and Arduino.

The goal is to cerate a master-slave channel on the USB in order to control an Arduino from a Android app. A possible logo for this “experiment” could be the following:

Arduino+androidMhhh…Android hides behind an Arduino. What a strange idea (and what a strange logo—>produced by ML)! 😀

Ok, I say clearly that I don’t like to use an Android phone as Arduino controller, since in my honest opinion writing an Android app in order to use the USB in master mode is not so simple and immediate. I prefer to use a linux single board computer (such as Raspberry PI) to control Arduino, as you can see in my previous post(s): here and here.

But the argument is very exciting and …”I was born ready” (cit. Jack Burton of “Big trouble in Chinatown” movie)! 😉

This is the “hand-made schema” of the complete system at the end of this post (click to view the zoomed image):



First step: verify the Arduino USB connection

Well, for my experiments I used the Arduino Mega ADK board (it has onboard the USB Host Max4321 controller ), but there is another chance: you can use the dear old Arduino Uno with the Arduino USB Host Shield 2.0 from Circuits@Home (or the alternative solution from SparkFun). My Arduino Mega ADK was part of the famous “Arduino on Android Kit” bought from Robot Italy (this has been the Monica gift for my birthday! 😉 ).

In order to verify the USB host capability of the Arduino I connected a USB memory stick to the USB host port, then I downloaded the USB Host Shield 2.0 library and I inserted it in the libraries folder of Arduino IDE.

IMPORTANT ACTION:  I opened the library file settings.h and I  modified the following line (note that the default for the define is =0, meaning that you are using the USB host shield instead Arduino Mega ADK):

#define USE_UHS_MEGA_ADK 1

This step is fundamental (if using Arduino IDE 1.0.5) because otherwise all sketches using USB Host library  will give the error “OSC DID NOT START” at runtime, since the function Usb.Init() will return a -1.

Once saved the modified file, I opened the library example script called USB_desc, and after the succesful compilation and download on the Arduino ADK, I opened the Arduino serial shell at 115200 bps.

The output reported all informations about the USB memory stick (vendor, class, ID etc.).

So, we can conclude that the USB host capability of the Arduino Mega ADK is OK.

…..Pheeew, now I can take a breath (and a break). 🙂


Second step: connect to Arduino an Android phone (or tablet) supporting the “Android Accessory Mode”

This is the hard truth: not all Android devices can enable the “Accessory Mode”, the necessary capability to talk with “accessories” (in our case the Arduino Mega ADK) via the ADK protocol. In these cases only the ADB protocol could be used… but this is another story! 😉

Note that the Accessory Mode is a capability depending on the Android version installed on your phone. 😦

For example,  my old Samsung Galaxy S (GT-I9000) has a too old Android version installed, so, in order to enable the Accessory Mode, I flashed on it the latest version of Cyanogen Mod.

And, at the same time, I had no problem using a Samsung Galaxy Tab 2 with his original firmware….since the Android version is newer and it supports Accessory Mode.

IMPORTANT ACTION: In order to enter automatically in Accessory Mode (if supported by the Android version), the mandatory step is to enable the “USB Debug mode” on the phone.

I opened and compiled the ArduinoBlinkLed  sketch from the ADK examples provided in the USB Host Library.

I powered ON the Arduino and I opened the Arduino shell (…and the encourageant sentence “Android accessory started” appeared ;-)).

Then I connected the Android device to the Arduino host USB. After a moment, the screen of the device reported “Accessory Mode entered” and after this a message appeared on the device requesting to download from internet the Android app associated  to the sketch.

The downloaded app (reported in the Arduino sketch) is, note that I didn’t found the sources for it… 😦

Anyway, starting the downloaded/installed app, a great button appeared on the device screen. And the result of this big effort activity is a little poor, but at the same time it’s very nice: clicking the software button, the Arduino LED 13 (the onboard led) turns ON/OFF!!! Yeahhhhhhhh! 🙂



The code on the Arduino side is (as always) very very very simple. The code on the Andoid side (the app), in order to manage the ADK protocol, in my opinion can be very difficult to be implemented, because it contains some strange instruction and construct.

In which mode I discovered it? Well… studying and compiling in the Android IDE an application similar to the “closed source” one used for my experiment. I found it in the ADK examples from Google Code or around Internet (it is called SkeletonApp) : you can download it from this link. Obviously you should compile this code in the Android IDE Eclipse in order to produce the app (i.e. the .apk file to install on your Android device).

Note that you could modify the ArduinoBlinkLed script in order to download/install from internet your own app modifying the following code:

ADK adk(&Usb, "ML Soft", // Manufacturer Name
              "ArduinoBlinkLED", // Model Name
              "Example sketch for the USB Host Shield", // Description (user-visible string)
              "1.0", // Version
              "http://YOUR_OWN_SITE_ADDRESS/SkeletonApp.apk", // URL (web page to visit if no installed apps support the accessory)
              "123456789"); // Serial Number (optional)

Ok boyz and girlz….this time we produced a very interesting  result. 😉

Now I need a very long time of relax… so I think I will launch a Debian kernel recompilation process (and in the meantime I will drink a good Grappa). 😀

Bye bye!



The dark side of porting Arduino sketches on Intel Galileo (part two)

Hi geek friends ( female & male)!

This is the post of the “real dark side” of porting external hardware control from Arduino to Intel Galileo. And, it’s just an example, a little sketch of the real work.

…Are you ready? Before starting this dangerous “trip” I want you send a first warning: unfortunately the x86 (the architecture of Intel Quark, the CPU inside the Intel Galileo) is very different from the architecture of the AVR (the Arduino MCU). So, registers, memory spaces etc. are completely different (Monty Python docet!).

My (insane, very insane 🙂 ) idea was to port some “lower level” code from Arduino Mega to Intel Galileo, in order to verify on my skin the real hardware differences between the two platforms and also in order to compare the “hardware level” performances.

I opened the “Arduino on Android kit” (a very appreciated gift from Monica! ;-)) and I found two very interesting hardware components: two ht1632c bicolor (red/green) led displays.

What a cool find! 😉 I love the shifting dysplays in the chinese stuff stores! 😀

So… I googled for already working driver on Arduino for these devices. I found some very interesting solution. The first one library is here, and it is very powerful and fast in my little opinion.

I tried on the Arduino Mega all the library demo sketches and I verified the correct work for my two displays. Looking inside the code I saw that all the library is based on AVR registers programming (using in every instruction all the possible bit-field functions, bit masks, bitwise operators and so on…).

Weahhhh…ok, I know this is the correct mode to write a driver, and it’s true that I wanted to go to a “lower level”…. but not so low! 😀

Indeed, once ported the code inside the Intel Galileo IDE, a so high number of “undefined references”  gave me the real proof that NOT ALL the AVR architecture has been ported by the Intel team in the Galileo development environment…. so we have two natural choices: the first one is to rewrite all the library using the Quark registers instead the AVR registers (but we are inside a Linux environment, it’s no so simple to manipulate the low level hardware without interact with the Linux kernel) or, the second choice is try to write a library at an higher level, using only the basic functionalities  (so using the native APIs) of Arduino.

I preferred the second oprion (…you suspected it, I know! :-)), so  I started looking for a little simpler (and without too many functionalities) library working directly on Arduino GPIOs, in order to simplify the porting phases (and possibly without losing my love in microelectronics 😉 )

I found the code  and the circuit reported on Arduino Playground (I love this site…because it’s a made in Italy product. You know, we don’t have only corruption, not-so-effordable persons & politicants… and soccer 😉 )….and -oh, oh- it was exactly what I was looking for. 😀

I took all the code and, after I removed the parts (code and hardware) related to the real time clock (because actually I don’t have a RTC!), I compiled the code in the Arduino IDE and I flashed it on my Arduino Mega. I obtained a “fixed hours and day” red and green clock on my two led displays. The draw of the displays is very fast (approx. immediate).

Ok, I ported the same code in the Galileo IDE and I obtained some compilation errors, tied to the hardware differences between Arduino and Galileo. This is the pinout for display I used:


Mainly Galileo IDE doesn’t have the <avr/pgmspace.h>… it’s natural since it’s a x86 CPU…but it is also a problem, because the great majority of third party lins use this file and its definitions (especially to declare some variable directly in the program flash, since Arduino doesn’t have so much RAM).

But since Galileo has a lot of RAM, it isn’t necessary to save data in the flash program space.

So, following the defines reported in avr/pgmspace.h , I changed in the file font1.h definitions:


in a simple

char* CHL[] = [...] .

After this, I removed the #include <avr/pgmspace.h> in the main .ino file,  and in the same file (function set_buffer()) I changed the line :

memcpy_P(buffer[j], (PGM_P)pgm_read_word(&(CHL[j+pos])), 8);


memcpy(buffer[j], (const char *)(&(CHL[j+pos])), 8);

Once resolved the errors, I compiled and flashed the code on Galileo.

I obtained a strange behavior: instead of the clock some strange character appeared on the two displays, with a very very (very! 😦 ) slow draw rate.

Ok, I think the strange characters are tied on a non perfect alignment on the memory in the x86 respect to the AVR  or to different sizes of some data type, especially due to the above memcpy porting  (but I didn’t investigated so much because I was worried by the displays slow draw rate). So, I changed the initial code in order to write a text on display pixel by pixel (note that this is the same approach of the original code), starting from drawing a single pixel in a certain (x,y) coordinate.

The differences between the initial code and my modified code can be easily found comparing the code in the page of Arduino Playground and the attached the zip file.

I attach the complete code as zip file since the code is too long for a blog post…and I think this post is already too long. But remember this is a “difficult” post. It MUST be long! 😉 Please excuse any commented code and some commentsin Italian…I know this is a lab “spaghetti code” . 😉

Ok, using this code the text is shown in the correct way on Intel Galileo (….to be investigated the strange drawing with the original code! 😉 ), but using Galileo the draw process took approx. 20 seconds (versus the Arduino result, which is minor than 1 second!!!) and with some different delay times between one pixel draw and the subsequent.

This is the final result (sorry for the up-down text, but I have very short wires between Galileo and the display…;-) ). In the background of the photo you can see two beautiful italian progressive rock cds by Maurizio di Tollo and by La Maschera di Cera (both my good friends), which have been the inspiration for my porting work. 🙂


Any ideas for this behavior (the slow drawing process)? I have one…but I don’t know if it is the correct idea.

As you know, Intel Galileo runs the Arduino sketches as Linux user processes (so, all kernel calls, interrupts, threads etc. have a higher priority  than a user process and so they can interrupt the execution of the Arduino skecth), whereas in Arduino no operating system is used (the sketch is a well-known “bare metal” code), so a real time behavior is a “true real time” behavior, and the sketch runs at the highest speed without interruptions.

So… what can I say? Intel Galileo is a really fast machine (compared to Arduino Mega or UNO) but in my little opinion it has some little “real time” problem when using the Arduino IOs (also I know my code is not optimized at all!!! 😉 ). And you? What do you think? 😉

Please, express your geek thinkings, and find al my errors! I will appreciate each contribution, especially  tied to my errors….the knowledge is always a mindstorm! 😉

Bye bye folks, now I go on my sofa to drink my brandy.

Another day is passed…another post is written. 🙂