Downloads

• AndropodInterface Software-Tutorial (en)
• AndropodInterface Software-Tutorial (de)
• AndropodInterface Schematics V1.2
• AndropodInterface Schematics V3.3
• AndropodInterface Hardware V1.2
• AndropodInterface Hardware V3.3
• AndropodInterface V0.9 beta
• AndropodInterface Logos

What is the AndropodInterface?

What makes the AndropodInterface so special?

What is the AndropodInterface for?

What allows me the AndropodInterface to do?

You want to read more about the Andropod Interface?

Sounds good – but expensive, right?

The AndropodInterface has been developed with the Upper Austria University of Applied Sciences, Hagenberg, Hard & Software Design degree program. Wanna become hardware & software designer? Visit  for more information!

See it in action!

Getting the hardware:

I  don’t care about how it works, i want to use it!

I want to modify the firmware myself

I want it small and modify the hardware to fit my needs!

WRITING the Android app

try
{
     //Create new server 
     ServerSocket socket = new ServerSocket(1337);
    
     //Wait until the andropodInterface is connected
     Socket andropodInterface = socket.accept();

     //Open streams
     PrintReader in = new BufferedReader(new InputStreamReader(andropodInterface.getInputStream()));
     PrintWriter out = new PrintWriter(andropodInterface.getOutputStream(), true);

    //Write what you want to write
    out.println("Hello Androdpod!");

     //Read what you want to read ;-)
    string message = in.readln();
}
catch (IOException e) 
{
    //Something went really wrong
}

 Connecting

1. Configure the Andropod Interface with your PC
   Install the Andropod Configuration Software on your PC, switch the Andropod Interface to “Configure Mode” (you will find an image with the correct jumper settings in the software) and connect it to your PC using a standard Micro USB cable. Then you can configure the baudrate an other settings as required by your application. Save all changes and you are ready to go.
2. Connect it to your robot, drone, gadget or other Hardware
   Use four simple wires, two for the supply voltage +5V, GND and the two serial RX and TX wires.
   The AndropodInterface needs 5V at around 550mA, in order to be able to charge the attached Android phone (if you disable that Android charges the phone when connected to USB, that the power consumption will be down to a few mA)
   Now one LED on the Andropod Interface should light up
3. Enable the USB Debugging in your Android phone
   This is needed in order to make the magic hapen – don’t forget to do that!
4. Connect your Phone to the AndropodInterface
   Now the second LED on the AndropodInterface should start blinking, and the phone should tell you that USB debugging is connected
5. Start your application on the Android phone!
   Now the second LED should go from blinking to permanent on
6. Your hardware is now an Andropod – have fun with it – put a Andropod logo on your hardware and send us pictures =)

HOW IT WORKS

First considerations

Embedded systems constantly evolve and developing state-of-the art systems for educational purposes is a very time consuming and expensive process. In order to provide the highest possible processing power along with sophisticated communication interfaces like Wireless Lan, HSDPA and Bluetooth to embedded projects using cheap and well tested high-end smart phones would be the best solution.

Currently the Smartphone market is split into a few different segments – the three major OSes are currently the Blackberry OS featured on most of the RIM (Research In Motion) devices, the iOS devices that is used on most Apple mobile devices and finally Google’s Open Source Android OS that is currently powering several hundred devices from multiple manufacturers.

When using Smartphones on for example Robotic projects the cost, the availability and the openness and power of the software framework are the key factors. Considering these factors the Open Source Android platform seems to meet the demands at best. The devices are really cheap (from around 100€ or less) and available from a variety of different hard manufacturers and the software is completely open, thus it’s an open source project distributed partially under the GNU GPL and the Apache Licensing model.

The big problem is how to communicate with Android-based mobile devices from custom embedded hardware in order to control robotics or for example sensor data. The general problem in this concern is that most Android devices (contrary to Apple devices) feature only one USB-OTG in port (a dual role – host or device – USB 2.0 port).

Main objective of this document is to discuss the mechanisms to interface Android devices with any simple serial (TTL-Serial, I²C, SPI) or parallel bus.

Another – on the first sight – more complex solution is to use the Android device’s USB controller in device mode, what requires the custom hardware to feature a more complex USB host port.

Using a host port simplifies the work that needs to be done on the Android smart phone itself what should – in the end – lead to a plug and play solution for all Android devices.

In order to ensure the plug and play experience that data exchange needs to be done over one of the following USB device classes already implemented in Android.

• USB mass storage device class (g_storage)
• USB Ethernet device class (g_ether)
• Android ADB debug interface (adb)

In general only the adb and the g_storage interface are implemented across all Android devices – the g_ether device made it as “USB Thethering” to Android 2.1 and might be problematic to use on devices that have no Baseband – like the Archos Tablets, or devices imported from the US – cell phone carriers tend to disable this feature to reduce the overall cell network usage and therefore increase net stability.

The g_storage interface:

The g_ether interface:

The ADB interface:

The discrete implementation

After considering everything learned in the previous chapter this chapter describes the implementation of a black-box USB host for Android device to serial solution based on the Android Debug interface.

As USB host a Vinculum II from FTDI is used. The VNCII is highly optimised USB controller that features two dual role USB ports in combination with a 16bit core with Harvard architecture, 256kb of flash memory and 16kb of RAM along with several communication interfaces (UART, SPI, 8-bit FIFO, …). The Vinculum II is priced at about 3.50€ for low quantity orders (10 part or more), what is quite cheap considering the prices of “normal” USB serial converters like the CP2102(2,56€) or the FT232 (5,10€).

FTDI provides a complete IDE with it’s VOS (Vinculum OS) that includes all necessary libraries for USB development, suitable evaluation kits start at 30€ and a fully featured debugger / programmer will cost around 20€ – so developing hardware with the VNC2 is really cheap and quite easy.

The Android Debug Bridge

The Android Debug Bridge is as its name says just a bridge between the debugging PC and the Android device. It allows tunneling TCP ports (for example to attach to debugging session to the gdb server) as well as remote access to the system shell and file exchange between the client and the host system.

Generally the ADB “driver” itself is always implemented in userspace (in Linux, Windows and Mac). The ADB software directly accesses the USB FIFOs of the USB device to be more specific the ADB uses only two FIFOs one incoming and one outgoing endpoint. The endpoints are bulk endpoints so no the data integrity is ensured by low-level USB layers. Considering all these facts the ADB USB layer is nothing more than a high speed serial connection that provides error handling and correction mechanisms.

The protocol on top of the USB connection is a simple as possible:

struct amessage {
unsigned command; /* command identifier constant */
unsigned arg0; /* first argument */
unsigned arg1; /* second argument */
unsigned data_length; /* length of payload (0 is allowed) */
unsigned data_check; /* checksum of data payload */
unsigned magic; /* command ^ 0xffffffff */
};
…
amessage msg;
unsigned char data[MAX_PAYLOAD];
…

The structure and the data (limited to a maximum packet size of 4kb) is sent over the USB connection. The 32 bit data fields are converted to little endian byte order.

HARDWARE

The hardware implementation is in general quite simple and the block diagram of an example system using the VNC2 should look like the following figure shows:

Everything explained

The processor

The Power Managment

USB Overcurrent protection

USB Connectors

VBus sensing

Debug interface

Serial connector

The 4 pin connector used for serial communication with the embedded hardware contains only the basic RX, TX and ground connection – to minimize complexity no hardware handshake has been implemented. The serial connector is also the main source for the system power – the system should supply 5V at 750mA to the board. The voltage must not be without a range of +/-10% around 5V – to be fully USB 2.0 compliant the voltage must not be without a range of 4.4V to 5.25V. As again this interface is considered to be “safe” and only a in system connection – no ESD precautions have been made.

FIRMWARE

struct amessage {
unsigned command; /* command identifier constant */
unsigned arg0; /* first argument */
unsigned arg1; /* second argument */
unsigned data_length; /* length of payload (0 is allowed) */
unsigned data_check; /* checksum of data payload */
unsigned magic; /* command ^ 0xffffffff */
};
…
amessage msg;
unsigned char data[MAX_PAYLOAD];
…

Gallery