Hello IOIO – Android

Hello IOIO Android

Here’s (finally) my first attempt at programming an Android phone AND interacting with the physical world at the same time… !

As many others, I was quite pleasantly surprised when during Google I/O 2011 they announced the Android Open Accessory standard / development kit…

And given that I was at the end of the autonomous tank project, I decided I HAD to get into this… it was the perfect occasion…

After some searching and looking around, I decided to buy a basic Android phone (Orange San Francisco or ZTE Blade) for around 90£ and go with the IOIO board from Sparkfun.

This choice might seem strange, as this is NOT an Android Open Accessory board (they’ve released new firmware that makes it compatible by supporting the ADK protocol !) BUT given the (lack of) availability of those, their size and price I decided it was better to go with this one, that also has the advantage to have been around for slightly longer…

Also it should be really straight forward to update the code from one standard to another.

Actually the MOST IMPORTANT reason of going with this board is that being based on the ADB (USB debugging) protocol it works with any version of Android >= 1.5. Google’s ADK protocol for the open accessory standard has only been implemented in 3.1 for tables and back ported to 2.3.4 for phones… Finding a 2.3.4 phone or upgrading one, is a pain…

So without further due, here’s a short video of my first Hello IOIO program, which simply blinks a LED, but provides 2 seek bars allowing you to change the frequency of the blinking and the brightness.

 

And here is the Java code for the Android:

package ioio.examples.hello;

import ioio.lib.api.DigitalOutput;
import ioio.lib.api.PwmOutput;
import ioio.lib.api.exception.ConnectionLostException;
import ioio.lib.util.AbstractIOIOActivity;
import android.os.Bundle;
import android.widget.SeekBar;
import android.widget.SeekBar.OnSeekBarChangeListener;
import android.widget.TextView;
import android.widget.ToggleButton;

/**
* This is the main activity of the HelloIOIO example application.
*/
public class MainActivity extends AbstractIOIOActivity {
private ToggleButton _button;
private SeekBar _seekBarFreq;
private SeekBar _seekBarBright;
private TextView _freq;
private TextView _bright;
private volatile int _delay;
private volatile float _brigthness;

/**
* Called when the activity is first created. Here we normally initialize our GUI.
*/
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
_button = (ToggleButton) findViewById(R.id.button);
_seekBarFreq = (SeekBar) findViewById(R.id.seekBarFreq);
_seekBarBright = (SeekBar) findViewById(R.id.seekBarBright);
_freq = (TextView) findViewById(R.id.textViewFreqVal);
_bright = (TextView) findViewById(R.id.textViewBrightVal);

_seekBarFreq.setMax(100);
_seekBarBright.setMax(100);

_seekBarFreq.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {
@Override
public void onStopTrackingTouch(SeekBar seekBar) {
}

@Override
public void onStartTrackingTouch(SeekBar seekBar) {
}

@Override
public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
_delay = (2000 * progress) / _seekBarFreq.getMax();
_freq.setText(String.valueOf(_delay));
}
});

_seekBarBright.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {
@Override
public void onStopTrackingTouch(SeekBar seekBar) {
}

@Override
public void onStartTrackingTouch(SeekBar seekBar) {
}

@Override
public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
_brigthness = (float)progress / (float)_seekBarBright.getMax();
_bright.setText(String.valueOf(_brigthness));
}
});
}

/**
* This is the thread on which all the IOIO activity happens. It will be run
* every time the application is resumed and aborted when it is paused. The
* method setup() will be called right after a connection with the IOIO has
* been established (which might happen several times!). Then, loop() will
* be called repetitively until the IOIO gets disconnected.
*/
class IOIOThread extends AbstractIOIOActivity.IOIOThread {
/** The on-board LED. */
private PwmOutput _led;

/**
* Called every time a connection with IOIO has been established.
* Typically used to open pins.
*
* @throws ConnectionLostException When IOIO connection is lost.
*
* @see ioio.lib.util.AbstractIOIOActivity.IOIOThread#setup()
*/
@Override
protected void setup() throws ConnectionLostException {
_led = ioio_.openPwmOutput(0, 300);
}

/**
* Called repetitively while the IOIO is connected.
*
* @throws ConnectionLostException When IOIO connection is lost.
*
* @see ioio.lib.util.AbstractIOIOActivity.IOIOThread#loop()
*/
@Override
protected void loop() throws ConnectionLostException {
try {
_led.setDutyCycle(1 - _brigthness);
sleep(_delay);
_led.setDutyCycle(1);
sleep(_delay);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

/**
* A method to create our IOIO thread.
*
* @see ioio.lib.util.AbstractIOIOActivity#createIOIOThread()
*/
@Override
protected AbstractIOIOActivity.IOIOThread createIOIOThread() {
return new IOIOThread();
}
}

Enjoy, and don’t hesitate to leave comments or questions…