Some of you must have already seen something like this:

Ikea Spoka Night Light

It’s an Ikea Spoka night light and my wife really loves them… to the point that a while back she bought several of them, “just in case”…

We obviously only use one, so I’ve gotten her permission a few months ago to open another one up and play with it.

This project started actually back at the beginning of October 2011, but after doing the hardest part of it (reverse engineering the simple circuit) I had to abandon it in favour of the Stanford Artificial Intelligence and Machine Learning courses, which took most of my week-ends !

Then my son was born at the end of November, and here I am, more than 3 months later, having decided that I need to do whatever it takes to finish the project and post it.

I’m trying to do this while waiting for some special “mega servos” that I plan to use to automate my baby’s bouncer (those of you that have babies, know how important it is to rock them while they try to fall asleep, and what is the phonic price to be paid if not careful… ).

So here we go…

Originally, the lamp has 2 modes, that you can select with a switch at the top (which can also turn it off):

1. slowly change between the 3 available colours (blue, red and orange) while dimming the intensity
2. keep the same colour and intensity

The “obvious” hack would be to be able to customize the patterns of light that it can display. Another one would be to make it able to synchronize to some random music.

However it occurred to me that both this “mods” and plenty of others could be easily achieved by making the lamp controllable remotely, and then “simply” sending whatever pattern we want from the controlling device. This way we offload the logic to some more powerful device.

It could also lead to having more than 1 lamp synchronised, but this would be for another project…

The first idea was to use these 2 simple wireless transceivers and control the Spoka from my PC.

Then it dawned on me that it would be much nicer to control it from my phone, and what better choice than the IOIO to interface Android with the serial transceiver… ?

And then, I can’t remember how, I found these ultra cheap serial bluetooth transceivers… There are plenty of them on various sites (I got mine from ebay for 5£) and they all seem more or less the same…

Not only it’s much cheaper than a IOIO + the RF transceivers, but it’s also quite small and especially, it doesn’t  require anything to be wired to the phone (since then the IOIO also supports bluetooth, but then it would mean to integrate one in the Spoka which is not an option…).

However, as you’ll see later in this post (and as Ytai told me from the beginning ), this advantages come at a price, as the module seems more fiddly and there’s hardly any documentation out there !

Anyhow, the thought of having this little thing integrated in the Spoka and then being able to remotely control it from my phone, felt worth the effort !

1. Reverse engineer the light

Original Circuits

Thank you Ikea for having easily hackable, through hole boards !

Spoka Schema

2. Replace the IC with a custom one

The original IC was a 8 pin one and I would have really liked to be able to just “drop” in my own ATtiny45 or 85. This however proved impossible due to a different pin layout.

Original MCU removed, wires soldered

There was also the need for serial communication with the bluetooth module and 3 independent PWM for the 3 colours. While I’m sure an experienced AVR engineer could fit all this on an ATtiny 45, the thought of implementing software serial and struggle with the conflicts with the PWM timers,  didn’t sound good and hence I opted for a 20pin ATtiny2313 that I had lying around and that provides hardware serial.

ATtiny2313 in place

ATtiny2313 in place 2

The job of the new MCU will be quite simple:

• wait for incoming serial data containing the intensity of each colour (and a checksum)
• provide some acknowledgement on the serial line
• update the PWM values accordingly

And here’s the C code.

Notice that I have actually implemented 2 modes:

1. if the first character is a ‘#’ then you simply provide the intensity for each colour
2. if the first character is a ‘*’ then you provide a delay only, and the MCU does the transitioning from one colour to the other (similarly to what the original setup was doing, but with the extra feature of being able to change the speed of transition)

/*
 * uart.h
 *
 * Created: 09/10/2011 Author: trandi
 */

#ifndef UART_H_
#define UART_H_

//BRR = (F_CPU / 16 / BaudRate ) - 1
#define BAUD_RATE_38400 (F_CPU / 16 / 38400 ) - 1
#define BAUD_RATE_4800 (F_CPU / 16 / 4800 ) - 1
#define BAUD_RATE_2400 (F_CPU / 16 / 2400 ) - 1

void uart_init(unsigned char baudrate);
uint8_t uart_isCharAvailable();
unsigned char uart_getChar();
void uart_putChar(unsigned char data);
void uart_putStr(const char* str);
//void uart_putw_dec(uint16_t w);

#endif /* UART_H_ */

/*
 * uart.c
 *
 * Created: 02/10/2011 Author: trandi
 */

#include <avr/io.h>
#include <util/delay.h>

void uart_init(unsigned char baudrate) {
 UBRRL = baudrate; // Set the baud rate

 UCSRB = _BV(RXEN) | _BV(TXEN); // Enable UART receiver and transmitter
 UCSRC = _BV(UCSZ1) | _BV(UCSZ0); // set to 8 data bits, 1 stop bit

 DDRD |= _BV(PD1); // TZ is output
 DDRD &= ~_BV(PD0); // RX is input
}

uint8_t uart_isCharAvailable() {
 return (UCSRA & _BV(RXC));
}

unsigned char uart_getChar() {
 while(! uart_isCharAvailable()) _delay_ms(10);
 char result = UDR;
 //useful echo
 uart_putChar(result);
 return result;
}

void uart_putChar(unsigned char data){
 /* Wait for empty transmit buffer */
 while (!(UCSRA & _BV(UDRE)));

/* Start transmission */
 UDR = data;
}

void uart_putStr(const char* str) {
 while(*str){
 uart_putChar(*str++);
 }
}

/*
void uart_putw_dec(uint16_t w) {
 uint16_t num = 10000;
 uint8_t started = 0;

while(num > 0){
 uint8_t b = w / num;
 if(b > 0 || started || num == 1){
   uart_putChar('0' + b);
   started = 1;
 }
 w -= b * num;

num /= 10;
 }
}*/

/*
 * SpokaLight.cpp
 *
 * Created: 01/10/2011 Author: trandi
 */

#define F_CPU 8000000UL
#include <avr/io.h>
#include <util/delay.h>
#include "uart.h"

#define PWM1 OCR0A //PB2
#define PWM2 OCR1B //PB3
#define PWM3 OCR1A //PB4
#define BLUE 0
#define RED 1
#define ORANGE 2
#define BUTTON_PORT PORTB // PORTx - register for button output
#define BUTTON_PIN PINB // PINx - register for button input
#define BUTTON_BIT PB1 // bit for button input/output

/*
n = (f / prescaler) * t Where n is the the number of timer ticks (as written in ICR1, OCR1A, OCR1B above).
f is the frequency you run the AVR at.
t is the wanted time.
You can compute this with f in Hz and t in seconds or often better with f in MHz and t in microseconds.
Notice for an 8MHz AVR with /8 prescaler this becomes
n = 8/8*t -> n = t
*/
void init_pwm(){
// OC1A, OC1B, OC0A outputs
 DDRB |= (1<<PB4)|(1<<PB3)|(1<<PB2);
 // TIMER 0
 // Fast PWM mode 3, Clear on compare, clear at TOP
 // TOP set for 255
 TCCR0A = (1<<COM0A0)|(1<<COM0A1)|(1<<WGM01)|(1<<WGM00);
 TCCR0B = (1<<CS00);

// TIMER 1
 // TOP, set for 255Hz
 ICR1 = 255;
 // Fast PWM mode 14, Clear on compare, clear at TOP
 TCCR1A = (1<<COM1A0)|(1<<COM1A1)|(1<<COM1B0)|(1<<COM1B1)|(1<<WGM11);
 TCCR1B = (1<<WGM13)|(1<<WGM12)|(1<<CS10);
}

void set_pwm(uint8_t colour, uint8_t value){
 uint8_t mapped_value = 255 - value;
 if(colour == BLUE) PWM3 = mapped_value;
 else if(colour == RED) PWM1 = mapped_value;
 else if(colour == ORANGE) PWM2 = mapped_value;
}

uint8_t button_is_pressed() {
 // the button is pressed when BUTTON_BIT is clear
 if (bit_is_clear(BUTTON_PIN, BUTTON_BIT)) {
   _delay_ms(25); // debounce time
   if (bit_is_clear(BUTTON_PIN, BUTTON_BIT)) {
   // wait for it to unclear before releasing... !
   while(bit_is_clear(BUTTON_PIN, BUTTON_BIT)) _delay_ms(10);
   return 1;
   }
 }

return 0;
}

// mode 0 - off / 1 - static colours / 2 - dynamic colours
volatile uint8_t _mode = 1;
volatile uint8_t _blue = 50, _red = 50, _orange = 50;
volatile uint8_t _currCol = BLUE, _currVal = 1, _dirUp = 1;
volatile uint16_t _interval = 30, _count = 0;

void update_status(){
 if(_mode == 0 ){
 set_pwm(BLUE, 0);
 set_pwm(RED, 0);
 set_pwm(ORANGE, 0);
 }else if(_mode == 1){
 set_pwm(BLUE, _blue);
 set_pwm(RED, _red);
 set_pwm(ORANGE, _orange);
 }else if(_mode == 2){
 set_pwm(BLUE, 0);
 set_pwm(RED, 0);
 set_pwm(ORANGE, 0);
 }
}

void update_dynamics(){
 // after 100 the intensity of LEDs seems to level off
 if(_currVal == 100) _dirUp = 0;
 else if(_currVal == 0) {
   _dirUp = 1;
   _currCol = (_currCol + 1) % 3;
 }

 _count ++;
 if(_count >= _interval){

_count = 0;
 _currVal = _dirUp ? _currVal + 1 : _currVal - 1;

if(_mode == 2){
 set_pwm(_currCol, _currVal);
 }
 }
}

uint8_t percToByte(uint8_t perc){
 uint16_t temp = perc * 255;
 return temp / 100;
}

int main(void){
 init_pwm();
 uart_init(BAUD_RATE_38400);

while(1){
 // 1. check for instructions over serial line
 if(uart_isCharAvailable()){
 uint8_t temp = uart_getChar();
 if(temp == '#'){
 _mode = 1;
 uart_putStr("BRO ");
 uint8_t blue = uart_getChar();
 uint8_t red = uart_getChar();
 uint8_t orange = uart_getChar();
 uint8_t checksum = uart_getChar(); //very basic check sum, it simply has to be = to the SUM of prev values, modulo 100

if(checksum == ((uint16_t)blue + (uint16_t)red + (uint16_t)orange) % 100){
 uart_putStr("OK");
 _blue = percToByte(blue);
 _red = percToByte(red);
 _orange = percToByte(orange);
 update_status();
 }else{
 uart_putStr("Nok");
 }
 }else if(temp == '*'){
 // go in mode "dynamic"
 _mode = 2;
 uart_putStr("Interval ");
 _interval = ((uint16_t)uart_getChar()) * 50;
 _currCol = BLUE;
 _currVal = 1;
 update_status();
 }
 }

// 2. check for button pressed or not
 if(button_is_pressed()){
 _mode = (_mode + 1) % 3;
 update_status();
 }

// 3. do whatever periodic action is needed
 update_dynamics();

// 4. get some rest
 //_delay_ms(1);
 }
}

Works just fine when connected to a PC serial port

3. Connect the bluetooth transceiver

Cheap Serial Bluetooth Transceiver

Bluetooth Serial connected, first tests...

4. Program the Android phone

This was (and still is) quite frustrating…

I love Android and its ease of programming in Java ! They really make your life much easier by providing everything one needs … Unless something doesn’t work as expected that is !

In my case, it was a matter of hours before I put together a simple view, like a joystick with 3 axes. It’s a simple gray dot that the user can move relative to 3 coloured circles, each corresponding to a set of LEDs on the lamp, which is supposed to update its intensity accordingly.

All the “back end” needs to do, is to measure the distance between the gray circle and the other 3 “reference” ones, transform this into a percentage and send it across the serial bluetooth line to the MCU.

Everything works nicely, EXCEPT the bluetooth serial port profile connection.

First of all, when I test the connection from the PC, there are no issues what so ever.

On Android however, I get garbled characters most of the time and sometimes the right one. It really feels like a timing issue…

I’ve based my code on the example coming with the Android SDK. The sending of bytes is done in the main thread, but the receiving has its own dedicated one.

The really strange thing is that depending on how and when I transform the bytes into a String, the code works or not…

If I disable the receiving thread and I only send data from the phone to the MCU, then it works 95% of the time, which again makes me think that it’s a timing issue on the Android side.

That’s for now the status, I basically send the instructions from the phone, and do NOT wait for the acknowledgement from the ATtiny.

Here’s the code. Ytai, you must have spend quite a lot of time on this yourself when bluetooth enabling the IOIO, if you have any idea or suggestion, it would be hugely appreciated !

BTDeviceListActivity.java
-------------------------------------------------------
package trandi.spokalightbluetooth;

import java.util.Set;

import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.Window;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ListView;
import android.widget.TextView;

/**
 * This Activity appears as a dialog. It lists any paired devices and
 * devices detected in the area after discovery. When a device is chosen
 * by the user, the MAC address of the device is sent back to the parent
 * Activity in the result Intent.
 */
public class BTDeviceListActivity extends Activity {
 // Debugging
 private static final String TAG = "BTDeviceListActivity";

 // Return Intent extra
 public static String EXTRA_DEVICE_ADDRESS = "device_address";

 // Member fields
 private BluetoothAdapter _btAdapter;
 private ArrayAdapter<String> _pairedDevicesArrayAdapter;
 private ArrayAdapter<String> _newDevicesArrayAdapter;

 // The BroadcastReceiver that listens for discovered devices and changes the title when discovery is finished
 private final BroadcastReceiver _receiver = new BroadcastReceiver() {
 @Override
 public void onReceive(Context context, Intent intent) {
 String action = intent.getAction();

// When discovery finds a device
 if (BluetoothDevice.ACTION_FOUND.equals(action)) {
 // Get the BluetoothDevice object from the Intent
 BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
 // If it's already paired, skip it, because it's been listed already
 if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
 _newDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());
 }
 // When discovery is finished, change the Activity title
 } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
 setProgressBarIndeterminateVisibility(false);
 setTitle(R.string.select_device);
 if (_newDevicesArrayAdapter.getCount() == 0) {
 _newDevicesArrayAdapter.add(getResources().getText(R.string.none_found).toString());
 }
 }
 }
 };

 // The on-click listener for all devices in the ListViews
 private OnItemClickListener _deviceClickListener = new OnItemClickListener() {
 @Override
 public void onItemClick(AdapterView<!--?--> av, View v, int arg2, long arg3) {
 // Cancel discovery because it's costly and we're about to connect
 _btAdapter.cancelDiscovery();

// Get the device MAC address, which is the last 17 chars in the View
 String info = ((TextView) v).getText().toString();
 String address = info.substring(info.length() - 17);

// Create the result Intent and include the MAC address
 Intent intent = new Intent();
 intent.putExtra(EXTRA_DEVICE_ADDRESS, address);

// Set result and finish this Activity
 setResult(Activity.RESULT_OK, intent);
 finish();
 }
 };

 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);

// Setup the window
 requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
 setContentView(R.layout.device_list);

// Set result CANCELED incase the user backs out
 setResult(Activity.RESULT_CANCELED);

// Initialize the button to perform device discovery
 Button scanButton = (Button) findViewById(R.id.button_scan);
 scanButton.setOnClickListener(new OnClickListener() {
 public void onClick(View v) {
 doDiscovery();
 v.setVisibility(View.GONE);
 }
 });

// Initialize array adapters. One for already paired devices and one for newly discovered devices
 _pairedDevicesArrayAdapter = new ArrayAdapter<String>(this, R.layout.device_name);
 _newDevicesArrayAdapter = new ArrayAdapter<String>(this, R.layout.device_name);

// Find and set up the ListView for paired devices
 ListView pairedListView = (ListView) findViewById(R.id.paired_devices);
 pairedListView.setAdapter(_pairedDevicesArrayAdapter);
 pairedListView.setOnItemClickListener(_deviceClickListener);

// Find and set up the ListView for newly discovered devices
 ListView newDevicesListView = (ListView) findViewById(R.id.new_devices);
 newDevicesListView.setAdapter(_newDevicesArrayAdapter);
 newDevicesListView.setOnItemClickListener(_deviceClickListener);

// Register for broadcasts when a device is discovered & discovery has finished
 this.registerReceiver(_receiver, new IntentFilter(BluetoothDevice.ACTION_FOUND));
 this.registerReceiver(_receiver, new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED));

// Get the local Bluetooth adapter
 _btAdapter = BluetoothAdapter.getDefaultAdapter();

// Get a set of currently paired devices
 Set pairedDevices = _btAdapter.getBondedDevices();

// If there are paired devices, add each one to the ArrayAdapter
 if (pairedDevices.size() > 0) {
 findViewById(R.id.title_paired_devices).setVisibility(View.VISIBLE);
 for (BluetoothDevice device : pairedDevices) {
 _pairedDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());
 }
 } else {
 _pairedDevicesArrayAdapter.add(getResources().getText(R.string.none_paired).toString());
 }
 }

 @Override
 protected void onDestroy() {
 super.onDestroy();

// Make sure we're not doing discovery anymore
 if (_btAdapter != null) {
 _btAdapter.cancelDiscovery();
 }

// Unregister broadcast listeners
 this.unregisterReceiver(_receiver);
 }

 /**
 * Start device discover with the BluetoothAdapter
 */
 private void doDiscovery() {
 Log.d(TAG, "doDiscovery()");

// Indicate scanning in the title
 setProgressBarIndeterminateVisibility(true);
 setTitle(R.string.scanning);

// Turn on sub-title for new devices
 findViewById(R.id.title_new_devices).setVisibility(View.VISIBLE);

// If we're already discovering, stop it
 if (_btAdapter.isDiscovering()) {
 _btAdapter.cancelDiscovery();
 }

// Request discover from BluetoothAdapter
 _btAdapter.startDiscovery();
 }
}

MainActivity.java
-------------------------------------------------------
package trandi.spokalightbluetooth;

import java.io.IOException;

import trandi.spokalightbluetooth.MainView.ColValues;
import trandi.spokalightbluetooth.MainView.JoystickListener;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.Window;
import android.widget.TextView;
import android.widget.Toast;

/**
 * Main activity to control the hacked Spoka light.
 *
 * @author trandi
 */
public class MainActivity extends Activity {
 // Debugging
 private static final String TAG = "SpokaLightBluetooth_MainActivity";

// Intent request codes
 private static final int REQUEST_CONNECT_DEVICE = 1;
 private static final int REQUEST_ENABLE_BT = 2;

 private TextView _title;
 private BluetoothAdapter _bluetoothAdapter;
 private Spoka _spoka;

 @Override
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 Log.e(TAG, "+++ ON CREATE +++");

// Set up the window layout
 requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);
 setContentView(R.layout.main);
 getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.custom_title);
 // register this activity with the View, to listen to Joystick events
 ((MainView)findViewById(R.id.myMainView)).addJoystickListener(new JoystickListener() {
 @Override
 public void onMove(ColValues newColours) {
 if(_spoka != null){
 final String result = _spoka.updateColours(newColours.red, newColours.blue, newColours.orange) ? "OK" : "NOK";

 Log.d(TAG, "Update Colours " + result + " (" + newColours + ")");
 }
 }
 });

// Set up the custom title
 _title = (TextView) findViewById(R.id.title_left_text);
 _title.setText(R.string.app_name);
 _title = (TextView) findViewById(R.id.title_right_text);

// Get local Bluetooth adapter
 _bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

// If the adapter is null, then Bluetooth is not supported
 if (_bluetoothAdapter == null) {
 Toast.makeText(this, "Bluetooth is not available", Toast.LENGTH_LONG).show();
 finish();
 return;
 }
 }

 @Override
 public void onStart() {
 super.onStart();
 Log.d(TAG, "++ ON START ++");

if (!_bluetoothAdapter.isEnabled()) {
 // If BT is not on, request that it be enabled.
 Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
 // Asynchronous, the onActivityResult will be called back when finished
 startActivityForResult(enableIntent, REQUEST_ENABLE_BT);
 }else {
 // Bluetooth is already enabled
 // Launch the BTDeviceListActivity to see devices and do scan
 Intent serverIntent = new Intent(this, BTDeviceListActivity.class);
 startActivityForResult(serverIntent, REQUEST_CONNECT_DEVICE);
 }
 }

@Override
 public void onDestroy() {
 super.onDestroy();
 Log.d(TAG, "++ ON DESTROY ++");

 if(_spoka != null) _spoka.disconnect();
 }

public void onActivityResult(int requestCode, int resultCode, Intent data) {
 Log.d(TAG, "onActivityResult " + resultCode);

 switch (requestCode) {
 case REQUEST_CONNECT_DEVICE:
 // When BTDeviceListActivity returns with a device to connect
 if (resultCode == Activity.RESULT_OK) {
 // Get the device MAC address
 String address = data.getExtras().getString(BTDeviceListActivity.EXTRA_DEVICE_ADDRESS);
 // Create a business object which attempts to create to the Spoka !
 //ensureDiscoverable(_bluetoothAdapter);
 try {
 _spoka = new Spoka(_bluetoothAdapter, address);
 } catch (Exception e) {
 Toast.makeText(this, "Can't connect to the SPOKA", Toast.LENGTH_SHORT).show();
 finish();
 }
 }
 break;
 case REQUEST_ENABLE_BT:
 // When the request to enable Bluetooth returns
 if (resultCode == Activity.RESULT_OK) {
 // Bluetooth is now enabled
 // Launch the BTDeviceListActivity to see devices and do scan
 Intent serverIntent = new Intent(this, BTDeviceListActivity.class);
 startActivityForResult(serverIntent, REQUEST_CONNECT_DEVICE);
 } else {
 // User did not enable Bluetooth or an error occured
 Log.d(TAG, "BT not enabled");
 Toast.makeText(this, "User did not enable Bluetooth or an error occured", Toast.LENGTH_SHORT).show();
 finish();
 }
 }
 }

 private void ensureDiscoverable(BluetoothAdapter bluetoothAdapter) {
 if (bluetoothAdapter.getScanMode() != BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE) {
 Log.d(TAG, "Force discoverable");
 Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
 discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
 startActivity(discoverableIntent);
 }
 }
}

MainView.java
-------------------------------------------------------
package trandi.spokalightbluetooth;

import java.util.ArrayList;
import java.util.List;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Point;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;

public class MainView extends View {
 private static final Point _red = new Point(50, 100);
 private static final Point _blue = new Point(250, 100);
 private static final Point _yellow = new Point(150, 300);

 private final List<JoystickListener> _joystickListeners = new ArrayList();

 private Point _joystick = new Point(150, 200);
 private final int _r = 30;
 private boolean _move = false;
 private long _lastMove = 0;

 public MainView(Context context, AttributeSet attrs) {
 super(context, attrs);
 }

 public synchronized void addJoystickListener(JoystickListener listener) {
 _joystickListeners.add(listener);
 }

 @Override
 public boolean onTouchEvent(MotionEvent me) {
 // are we trying to move the "joystick"
 if(Math.abs(me.getX() - _joystick.x) <= _r && Math.abs(me.getY() - _joystick.y) <= _r){
 if(me.getAction() == MotionEvent.ACTION_DOWN){
 _move = true;
 }else if(me.getAction() == MotionEvent.ACTION_UP){
 _move = false;
 }else if(me.getAction() == MotionEvent.ACTION_MOVE
 && _move
 && (System.currentTimeMillis() - _lastMove > 50))
 {
 _lastMove = System.currentTimeMillis();
 // call all the listeners
 new Thread(){
 @Override
 public void run(){
 ColValues updatedColours = new ColValues();
 for(JoystickListener listener : _joystickListeners){
 listener.onMove(updatedColours);
 }
 }
 }.start();
 }
 }

 if(_move){
 _joystick.set(Math.round(me.getX()), Math.round(me.getY()));

 // force to redraw
 this.invalidate();
 }

 return true;
 }

 @Override
 protected void onDraw(Canvas canvas) {
 super.onDraw(canvas);

 // draw the fixed circles
 Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
 paint.setColor(Color.RED);
 canvas.drawCircle(_red.x, _red.y, 20, paint);
 paint.setColor(Color.BLUE);
 canvas.drawCircle(_blue.x, _blue.y, 20, paint);
 paint.setColor(Color.YELLOW);
 canvas.drawCircle(_yellow.x, _yellow.y, 20, paint);

 // draw the moving circle (the "joystick")
 paint.setColor(Color.GRAY);
 canvas.drawCircle(_joystick.x, _joystick.y, _r, paint);
 }

 public static interface JoystickListener {
 void onMove(ColValues newColours);
 }

 public class ColValues {
 public final int red;
 public final int blue;
 public final int orange;

 public ColValues(int red, int blue, int orange){
 this.red = red;
 this.blue = blue;
 this.orange = orange;
 }

 /**
 * Calculates the distances from the position of the joystick and base colour circles
 */
 public ColValues(){
 final double maxDist = getDist(_red, _blue);

this.red = 100 - (int)Math.round(getDist(_joystick, _red) * 100.0 / maxDist);
 this.blue = 100 - (int)Math.round(getDist(_joystick, _blue) * 100.0 / maxDist);
 this.orange = 100 - (int)Math.round(getDist(_joystick, _yellow) * 100.0 / maxDist);
 }

 private int getDist(Point a, Point b) {
 return (int)Math.round(Math.sqrt(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2)));
 }

@Override
 public String toString() {
 return "ColValues [red=" + red + ", blue=" + blue + ", orange=" + orange + "]";
 }
 }
}

Spoka.java
-------------------------------------------------------
package trandi.spokalightbluetooth;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.UUID;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.util.Log;

public class Spoka {
 // Debugging
 private static final String TAG = "SPOKA";

 // Unique UUID for this application
 // has to be this precise value for SERIAL port profile (SPP)
 private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
// private static final UUID MY_UUID_SECURE = UUID.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66");
// private static final UUID MY_UUID_INSECURE = UUID.fromString("8ce255c0-200a-11e0-ac64-0800200c9a66");

 private BluetoothSocket _btSocket;
 private InputStream _socketIS;
 private OutputStream _socketOS;
 // will need to SYNCHRONISE on this as it's used from multiple threads !
// private Queue<String> _incomingData = new ConcurrentLinkedQueue<String>();
// private String _incomingDataStr = "";

 public Spoka(BluetoothAdapter bluetoothAdapter, String address) throws IOException{
 Log.d(TAG, "++ CONNECT SPOKA ++");

// Get the BluetoothDevice object
 BluetoothDevice device = bluetoothAdapter.getRemoteDevice(address);

 // Get a BluetoothSocket for a connection with the given BluetoothDevice
 try {
 _btSocket = device.createRfcommSocketToServiceRecord(MY_UUID);
 } catch (IOException e) {
 Log.e(TAG, "createRfcommSocketToServiceRecord() failed", e);
 throw e;
 }

// Attempt to connect to the device
 // Always cancel discovery because it will slow down a connection
 bluetoothAdapter.cancelDiscovery();

 // Make a connection to the BluetoothSocket
 try {
 // This is a blocking call and will only return on a successful connection or an exception
 _btSocket.connect();
 Log.d(TAG, "++ connectED SPOKA ++");
 } catch (IOException e) {
 disconnect();
 Log.e(TAG, "Can't connect to the Spoka", e);
 throw e;
 }

 // !!! COMMENTED OUT THE WHOLE INCOMING SERIAL DATA READ, AS THIS SEEMS TO CAUSE THE RECEIVED BYTES TO BE GARBLED !!!
 // start a separate thread that monitors any incoming data, and stores it in a queue
 // this is done so, because we don't seem to have an asynchronous read() on the BluetoothSocket InputStream
// new Thread(){
// @Override
// public void run(){
// byte[] buff = new byte[100];
// while(true){
// try{
// if(_socketIS == null) _socketIS = new BufferedInputStream(_btSocket.getInputStream(), 1024);
//
// if(_socketIS != null){
// // blocking on the read when there's nothing...
// int readCount = _socketIS.read(buff);
// // for some VERY SILLY reason, if we store the bytes here, they come garbled...
// _incomingData.add(new String(buff, 0, readCount));
// }
// } catch (Exception e) {
// Log.e(TAG, "Can't read message from the Spoka", e);
// }
// }
// }
// }.start();
 }

 public void disconnect() {
 try {
 if(_btSocket != null) _btSocket.close();
 } catch (IOException e) {
 Log.e(TAG, "Unable to close() socket during connection failure", e);
 }
 }

 public boolean updateColours(int redPerc, int bluePerc, int orangePerc) {
 byte red = checkPerc(redPerc);
 byte blue = checkPerc(bluePerc);
 byte orange = checkPerc(orangePerc);

 // 1. send the special char "#" indicating to the Spoka that we want to manually update the colours
 sendBytes((byte)'#');

 // 2. check that we receive back the "BRO " acknowledgement( Blue, Red, Orange)
 //if(waitForIncomingData("BRO", 100)){
 // 3. send the values & the check sum
 sendBytes(blue, red, orange, (byte)(((int)blue + (int)red + (int)orange) % 100));

 // 4. check that we receive back confirmation
 //return waitForIncomingData("OK", 100);
 //}

 return false;
 }

 private byte checkPerc(int perc){
 return (byte)(perc < 0 ? 0 : (perc > 100 ? 100 : perc));
 }

 private void sendBytes(byte...bytes) {
 try{
 if(_socketOS == null) _socketOS = new BufferedOutputStream(_btSocket.getOutputStream(), 1024);

 if(_socketOS != null){
 _socketOS.write(bytes);
 _socketOS.flush();
 }
 } catch (IOException e) {
 Log.e(TAG, "Can't send message to the Spoka", e);
 }
 }

 private boolean waitForIncomingData(String expectedData, int timeoutMillis){
 final long startTime = System.currentTimeMillis();
 byte[] buff = new byte[100];
 String incomingData = "";
 try{
 if(_socketIS == null) _socketIS = new BufferedInputStream(_btSocket.getInputStream(), 1024);

 if(_socketIS != null){
 while((! incomingData.contains(expectedData))
 && (System.currentTimeMillis() - startTime < timeoutMillis))
 {
 // blocking on the read when there's nothing...
 int readCount = _socketIS.read(buff);
 // for some VERY SILLY reason, if we store the bytes here, they come garbled...
 incomingData += new String(buff, 0, readCount);
 }
 }
 }catch(IOException e){
 Log.e(TAG, "Can't receive incoming data", e);
 }

 Log.d(TAG, "RECV: " + incomingData);

 if(incomingData.contains(expectedData)){
 return true;
 }

return false;
 }

// private boolean waitForIncomingData(String expectedData, int timeoutMillis){
// final long startTime = System.currentTimeMillis();
//
// while((! _incomingDataStr.contains(expectedData))
// && (System.currentTimeMillis() - startTime < timeoutMillis))
// {
// final String head = _incomingData.poll();
// if(head != null) _incomingDataStr += head;
// Thread.yield();
// }
//
// if(_incomingDataStr.contains(expectedData)){
// // REMOVE the expected data (and whatever was before) from the string buffer
// final int pos = _incomingDataStr.indexOf(expectedData) + expectedData.length();
// _incomingDataStr = _incomingDataStr.substring(pos);
//
// return true;
// }
//
// Log.d(TAG, "RECV: " + _incomingDataStr);
// return false;
// }

// /**
// * @return true if the expected incoming data has been received, false if timeout
// */
// private boolean waitForIncomingData(String incomingData, int timeoutMillis){
// final long startTime = System.currentTimeMillis();
// // wait until received expected data or timeout
// while(! peekIncomingData().contains(incomingData) && (System.currentTimeMillis() - startTime < timeoutMillis)){
// try {
// Thread.sleep(10);
// } catch (InterruptedException e) {
// // nothing to do
// }
// }
//
// final int position = peekIncomingData().indexOf(incomingData);
// if(position > 0){
// // now remove the data from the incoming queue
// for(int i=0; i < position + incomingData.length(); i++){
// _incomingData.poll();
// }
// return true; // found the expected string
// }else{
// Log.e(TAG, peekIncomingData());
// }
//
// return false; // NOT found the expected string and timed out
// }
//
// private String peekIncomingData() {
// Byte[] data = _incomingData.toArray(new Byte[]{});
// byte[] dataChars = new byte[data.length];
// for(int i=0; i
// dataChars[i] = data[i];
// }
// return new String(dataChars);
// }
}

And here are all the XML configuration files, specific to Android platforms:

custom_title.xml
-------------------------------------------------------
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 android:layout_width="match_parent"
 android:layout_height="match_parent"
 android:gravity="center_vertical">

 <TextView android:id="@+id/title_left_text"
 android:layout_alignParentLeft="true"
 android:ellipsize="end"
 android:singleLine="true"
 style="?android:attr/windowTitleStyle"
 android:layout_width="wrap_content"
 android:layout_height="match_parent"
 android:layout_weight="1"/>

 <TextView android:id="@+id/title_right_text"
 android:layout_alignParentRight="true"
 android:ellipsize="end"
 android:singleLine="true"
 android:layout_width="wrap_content"
 android:layout_height="match_parent"
 android:textColor="#fff"
 android:layout_weight="1"/>

</RelativeLayout>

device_list.xml
-------------------------------------------------------
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 android:orientation="vertical"
 android:layout_width="match_parent"
 android:layout_height="match_parent">

 <TextView android:id="@+id/title_paired_devices"
 android:layout_width="match_parent"
 android:layout_height="wrap_content"
 android:text="@string/title_paired_devices"
 android:visibility="gone"
 android:background="#666"
 android:textColor="#fff"
 android:paddingLeft="5dp"/>

 <ListView android:id="@+id/paired_devices"
 android:layout_width="match_parent"
 android:layout_height="wrap_content"
 android:stackFromBottom="true"
 android:layout_weight="1"/>

 <TextView android:id="@+id/title_new_devices"
 android:layout_width="match_parent"
 android:layout_height="wrap_content"
 android:text="@string/title_other_devices"
 android:visibility="gone"
 android:background="#666"
 android:textColor="#fff"
 android:paddingLeft="5dp"/>

 <ListView android:id="@+id/new_devices"
 android:layout_width="match_parent"
 android:layout_height="wrap_content"
 android:stackFromBottom="true"
 android:layout_weight="2"/>

 <Button android:id="@+id/button_scan"
 android:layout_width="match_parent"
 android:layout_height="wrap_content"
 android:text="@string/button_scan"/>

</LinearLayout>

device_name.xml
-------------------------------------------------------
<?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
 android:layout_width="match_parent"
 android:layout_height="wrap_content"
 android:textSize="18sp"
 android:padding="5dp"/>

main.xml
-------------------------------------------------------
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 xmlns:trandi= "http://schemas.android.com/apk/res/trandi.spokalightbluetooth"
 android:orientation="vertical"
 android:layout_width="match_parent"
 android:layout_height="match_parent">

 <FrameLayout android:id="@+id/drawingFrame" android:layout_height="match_parent" android:layout_width="match_parent">
 <trandi.spokalightbluetooth.MainView android:id="@+id/myMainView" android:layout_height="match_parent" android:layout_width="match_parent"/>
 </FrameLayout>
</LinearLayout>

strings.xml
-------------------------------------------------------
<?xml version="1.0" encoding="utf-8"?>
<resources>
 <string name="app_name">Spoka Light Bluetooth</string>

 <!-- BTDeviceListActivity -->
 <string name="scanning">scanning for devices...</string>
 <string name="select_device">select a device to connect</string>
 <string name="none_paired">No devices have been paired</string>
 <string name="none_found">No devices found</string>
 <string name="title_paired_devices">Paired Devices</string>
 <string name="title_other_devices">Other Available Devices</string>
 <string name="button_scan">Scan for devices</string>
</resources>

5. Final result

Everything connected, ready for final tests

On the stripboard

Putting everything back

Naked, without the silicone skin...

I’ve been looking for a simple and cheap wireless serial data solution for quite a while now…

No specific usage, but things like every time you integrate your Arduino into a project and then 2 days later you want to update the code and you have to dismount everything, or simply remote control a project or more generally just getting tired of “all the wires”…

There are of course plenty of solutions out there, but I wanted something cheap and simple to use !

The WiFly solution that I’ve already used here, is “ok” simplicity wise but far too expensive !

Then you have RF link devices like this one, which are really cheap indeed … but as simple as they might be to install, they get a fair amount of noise so you get added complexity in the code to filter out some of that noise and do some error checks…

Anyhow, I’m sure I could go on forever like this, again one of the reasons I haven’t gotten anything until now, it’s that I couldn’t decide what to go with !

Finally, I got 2 of these TRX-MID Aurel boards from Farnell  (quite reliable guys, I use them whenever I can, it’s a shame they seem to be more oriented towards professionals than hobbyists…) :

• they are 2-3 times more expensive than the really basic ones (12£ here in the UK, probably ~ 15$ in the US)
• they are transceivers, which means you can have bi-directional communication
• they seem to be slightly higher specs, so I hope for less noise / more reliable communication

Aurel TRX-MID-3V Close Up

Before I insert them into any project, I need to do some testing / benchmarking to get a feeling for how good / bad they really are.

The simplest setup would have been to connect both of them to the PC through 2 USB to serial adapters, BUT given that I have only 1 3.3Volts cable, I had to use something else…

The next “simplest” solution was for me to use the IOIO board, connected to an Android phone. I know, it doesn’t sound very simple, but it’s a 3V3 board and it’s really quick to write a few lines of Java to make it send some serial data periodically:

Aurel TRX-MID-3V Test Configuration Schema

• TX

• the Android phone and the IOIO are there simply to periodically send some serial data
• GND and VCC come directly from the IOIO board
• pin 6 / Enable is connected to VCC through a 10k resitor
• pin 5 / TX/RX is connected to VCC, telling the transceiver that it’s in TX mode
• pin 4 / Input Data is connected to pin 5 of the IOIO

• RX

• the FTDI USB – Serial cable connecting the transceiver directly to the PC, on which I used Tera Term
• GND and VCC come directly from the FTDI cable
• pin 6 / Enable is connected to VCC through a 10k resistor
• pin 5 / TX/RX is not connected, telling the transceiver it’s in RX mode (same as if I had connected it to GND, I think it has an internal pull down resistor connected to it)
• pin 9 / Data Out is connected to the RX pin of the cable

Aurel TRX-MID-3V

Aurel TRX-MID-3V Test Setup Overview

 

All in all, it’s a fairly simple connectivity, it literally took me 10minutes to set all this up, and then it worked from the 1st try !

 

Now it’s time for a quick test, which consisted of simply seeing the “Hello World” sent by the IOIO board display in the serial terminal on the PC, and then take the board in another room (~5meters and 2 walls apart).

 

Everything worked well (at 9600bps), but when I took the transmitter to the other room, I would get some spurious characters at the end of each transmission. I haven’t fully investigated this, but it seems that without an external antenna, the range is really 5-10 meters, no more. One can obviously add some error checking in the software or lower the bps to extend that.

 

• I like

• the fact that you can start into RX / TX mode by simply pulling a pin down / up (as oposed to the user manual where they describe a fairly complicated sequence (“From powerdown mode (pin 4-5-6 low), drive high pin 6 (ENABLE), then after 20us drive high pin 5 (RX/TX) 200us, hold on 40us and then drive down 20us pin 6 (ENABLE).“) which I’m sure it’s necessary in some more complex use cases
• don’t have to set the speed

• I dislike

• you need an extra wire to set TX/RX, it’s not full duplex (can’t send / receive at the same time) – that’s really not problem for connecting remote sensors for example, but it makes it virtually impossible to use these boards to make an Arduino fully wireless
• limited at 9600bps, again ok for some sensors, not really enough to replace wires (most of the applications expect at tleast 115200bps)
• the range – this can be mediated by adding an antenna, but that makes things more complex

All in all, it’s a nice and easy to use product, better than the basic ones as it can do both TX and RX (though not simultaneously), but it’s uses seem limited to sensors feedback type of use cases, definitely not making your micro-controller fully wireless by replacing the wired connection and debugging remotely.

package org.trandi.helloioio;

import ioio.lib.api.DigitalOutput;
import ioio.lib.api.Uart;
import ioio.lib.api.exception.ConnectionLostException;
import ioio.lib.util.AbstractIOIOActivity;

import java.io.OutputStream;
import java.lang.Thread.UncaughtExceptionHandler;

import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;

public class MainActivity extends AbstractIOIOActivity {
	private static final String LOG_TAG = "APT";
	private static final int RX_PIN = 4;
	private static final int TX_PIN = 5;
	private static final int UART_SPEED = 9600;

	private MyIOIOThread _IOIOthread;

	private TextView _msg;

	/**
	 * Called when the activity is first created. Here we normally initialise our GUI.
	 */
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
			@Override
			public void uncaughtException(Thread thread, Throwable ex) {
				Log.e(LOG_TAG, "", ex);
			}
		});

		setContentView(R.layout.main);
		_msg = (TextView) findViewById(R.id.textViewMsg);
	}

	/**
	 * 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 MyIOIOThread extends AbstractIOIOActivity.IOIOThread {
		private DigitalOutput _onboardLED; // The on-board LED
		private Uart _uart;
		private OutputStream _dataOS;
		private long _count = 0;

		/**
		 * Called every time a connection with IOIO has been established.
		 * Typically used to open pins.
		 *
		 * @throws ConnectionLostException When IOIO connection is lost.
		 */
		@Override
		protected void setup() throws ConnectionLostException {
			msg("IOIO Connected !", null);

			try {
				_onboardLED  = ioio_.openDigitalOutput(0, true);

				// initialize the UART
				if(_uart != null) _uart.close();
				_uart = ioio_.openUart(RX_PIN, TX_PIN, UART_SPEED, Uart.Parity.NONE, Uart.StopBits.ONE);
				_dataOS = _uart.getOutputStream();
				msg("Connected to UART", null);
			} catch (Throwable e) {
				msg("Can't connect to the UART (" + RX_PIN + ", " + TX_PIN + ", " + UART_SPEED + ")", e);
			}
		}

		/**
		 * Called repetitively while the IOIO is connected.
		 *
		 * @throws ConnectionLostException When IOIO connection is lost.
		 */
		@Override
		protected void loop() throws ConnectionLostException {
			try {
				onboardLED(true);
				final String msg = "HelloWorld  " + _count++ + "\n";
				runOnUiThread(new Runnable(){
					@Override
					public void run() {
						_msg.setText(msg);
					}
				});
				_dataOS.write(msg.getBytes());
				onboardLED(false);
				Thread.sleep(1000);
			} catch (Exception e) {
				msg("Can't write serial data", e);
			}
		}

		private void onboardLED(boolean on) throws ConnectionLostException{
			_onboardLED.write(!on);
		}

	} // end IOIOThread

	private void msg(final String msg, final Throwable e){
		runOnUiThread(new Runnable() {
			@Override
			public void run() {
				_msg.setText(msg + (e != null ? " - " + e.getMessage() : ""));
			}
		});
	}

	/**
	 * A method to create our IOIO thread.
	 */
	@Override
	protected AbstractIOIOActivity.IOIOThread createIOIOThread() {
		_IOIOthread = new MyIOIOThread();
		return _IOIOthread;
	}
}

This is a slightly different post for me, in that it’s about some help I gave to 2 guys in Germany, working on a hydraulic anti-roll system for a tractor.
Wow… I never though I would be working on “revolutionising the agriculture” as they’ve put it…

Basic Atom Pro M40 - IOIO - and the ICONIA A500 Android tablet

It sounds awesome, but my actual contribution is very limited.

The Basic Atom Pro M40 is connected to an inclination sensor and does some funky stuff for the anti-rolling system, but the guys wanted to have some data nicely displayed on an Android tablet.

And that’s where they needed my help…

They initially wanted to use I2C to connect the IOIO to the Basic Atom, which I thought was fine, until I realised that the IOIO can NOT be a I2C slave… I therefore convinced them it would be easier to go down the UART route and after throwing together a simple program, we seem to be in business !

There’s really not much else to say, the program is really trivial, but it’s a nice basic example on how to use a USART on the IOIO board !

Without further due, here’s the main and only class  I2CAtomProTractorActivity :

package com.trandi.i2catompro;

import ioio.lib.api.DigitalOutput;
import ioio.lib.api.Uart;
import ioio.lib.api.exception.ConnectionLostException;
import ioio.lib.util.AbstractIOIOActivity;

import java.io.InputStream;
import java.lang.Thread.UncaughtExceptionHandler;

import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;

public class I2CAtomProTractorActivity extends AbstractIOIOActivity {
	private static final String LOG_TAG = "APT";
	private static final int RX_PIN = 4;
	private static final int TX_PIN = 5;
	private static final int UART_SPEED = 9600;

	private MyIOIOThread _IOIOthread;

	private TextView _varField;
	private TextView _msg;

	/**
	 * Called when the activity is first created. Here we normally initialise our GUI.
	 */
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
			@Override
			public void uncaughtException(Thread thread, Throwable ex) {
				Log.e(LOG_TAG, "", ex);
			}
		});

		setContentView(R.layout.main);
		_varField = (TextView) findViewById(R.id.textViewVarVal);
		_msg = (TextView) findViewById(R.id.textViewMsg);
	}

	/**
	 * 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 MyIOIOThread extends AbstractIOIOActivity.IOIOThread {
		private DigitalOutput _onboardLED; // The on-board LED
		private Uart _uart;
		private InputStream _atomDataIS;
		private final byte[] _data = new byte[2];

		/**
		 * Called every time a connection with IOIO has been established.
		 * Typically used to open pins.
		 *
		 * @throws ConnectionLostException When IOIO connection is lost.
		 */
		@Override
		protected void setup() throws ConnectionLostException {
			msg("IOIO Connected !", null);

			try {
				_onboardLED  = ioio_.openDigitalOutput(0, true);

				// initialize the UART
				if(_uart != null) _uart.close();
				_uart = ioio_.openUart(RX_PIN, TX_PIN, UART_SPEED, Uart.Parity.NONE, Uart.StopBits.ONE);
				_atomDataIS = _uart.getInputStream();
				msg("Connected to UART", null);
			} catch (Throwable e) {
				msg("Can't connect to the UART (" + RX_PIN + ", " + TX_PIN + ", " + UART_SPEED + ")", e);
			}
		}

		/**
		 * Called repetitively while the IOIO is connected.
		 *
		 * @throws ConnectionLostException When IOIO connection is lost.
		 */
		@Override
		protected void loop() throws ConnectionLostException {
			try {
				if(_atomDataIS.available() > 0) {
					onboardLED(true);
					if(_atomDataIS.read() == '#'){
						// this is a message for us, expect 2 more bytes
						_atomDataIS.read(_data, 0, _data.length);
						msg("Bytes[" + _data[0] + ", " + _data[1] + "]", null);

						// transform the 2 bytes into an integer
						final int number = _data[0] + _data[1] << 8;

						// refresh the display (HAS to be on the UI Thread !)
						runOnUiThread(new Runnable() {
							@Override
							public void run() {
								_varField.setText(String.valueOf(number));
							}
						});
					}

					onboardLED(false);
				}

				// don't overheat the CPU
				Thread.sleep(10);
			} catch (Exception e) {
				msg("Can't read serial data", e);
			}
		}

		private void onboardLED(boolean on) throws ConnectionLostException{
			_onboardLED.write(!on);
		}

	} // end IOIOThread

	private void msg(final String msg, final Throwable e){
		runOnUiThread(new Runnable() {
			@Override
			public void run() {
				_msg.setText(msg + (e != null ? " - " + e.getMessage() : ""));
			}
		});
	}

	/**
	 * A method to create our IOIO thread.
	 */
	@Override
	protected AbstractIOIOActivity.IOIOThread createIOIOThread() {
		_IOIOthread = new MyIOIOThread();
		return _IOIOthread;
	}

The layout/main.xml :

<!--?<span class="hiddenSpellError" pre=""-->xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">

<TextView android:text="Inclination: " android:id="@+id/textViewVar" android:layout_width="wrap_content" android:layout_height="wrap_content">
id="@+id/textViewVarVal" android:textAppearance="?android:attr/textAppearanceLarge" android:layout_width="wrap_content" android:layout_height="wrap_content">
<TextView  android:text="Message" android:id="@+id/textViewMsg"  android:layout_height="wrap_content" android:layout_width="wrap_content"></TextView>

</LinearLayout>

And finally the AndroidManifest.xml file :

<?xml version="1.0" encoding="utf-8"?>
xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.trandi.i2catompro"
      android:versionCode="1"
      android:versionName="0.1">
    <uses-sdk android:minSdkVersion="3" />
    <uses-permission android:name="android.permission.INTERNET"></uses-permission>

    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".I2CAtomProTractorActivity"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

    </application>
</manifest>

It is able to :

1. get the time from the internet and automatically synchronise itself (why have to set the time and use a battery to keep it running when disconnected, if we have Internet access ?)
2. periodically fetch some weather data and display it
3. do searches on Twitter and display the 1st result

So rather than “simply” displaying the time, every 15secs it alternates between the time, the weather and a Twitter message.

Building this clock from Ladyada’s kit was all nice and fun, but almost too simple to be fully rewarding…

So I started having a look at the firmware and trying to modify it to make it do more interesting stuff.

Step 1 – Add scrolling text

Adding custom text wasn’t hard, I just had to insert a new mode in the state machine logic, and then to make it scroll I had to call a custom method from one of the interrupts occurring every millisecond that would move all the display[] array (containing the text currently displayed) one position to the left.

VFD Clock Scrolling Hello World

The ease with which I was able to insert new logic into the code, and get something working in literally a couple of hours, shows how nicely the code was initially written… all the logic is in one big file, which might seem hard to follow initially, but it’s nicely commented and divided into methods… thank you Ladyada !

Step 2 – Connect to the serial port

There’s not much point in being able to display some custom text, if it has to be hard-coded into the firmware… so the obvious next step was to make it easy to send data to the AtMega168 which drives this clock.

I hesitated between the serial and the I2C ports. I’m a big fan of I2C which I like much more than simple serial, as you can have plenty of different slaves…

I however went for serial, mainly because there was already code in the firmware that was communicating on that port for debugging purposes. There was also already a mod using this port, so overall it would be much quicker / easier to use this instead of I2C.

So let’s solder the wires to expose this port (pins 2 & 3 of the AtMega 168) :

VFDClock Soldering Wires to the Serial Port

I’ve also added 2 wires to GND and +5V.

Now we can mount the bottom of the case back :

VFDClock Soldering Wires to the Serial Port 2

And here is the final result, with the case mostly put back and the wires getting out of it through the battery hole:

VFDClock Soldering Wires to the Serial Port 3

Step 3 – Integrate a WiFi board (WiFly / RN-134)

This is all nice and good, BUT a clock like this is not supposed to stay connected to a PC to keep receiving messages… it would be nice if it could just sit there by itself, and periodically get data from the Internet and display it…

The initial idea was to simply make it display some tweets, but then I thought it would be really simple and quite useful for when I leave for work in the morning to see some weather forecast. Also, as I was working on these 2 goals I realised that with an Internet connection it is really easy to get the current exact time, so why bother setting it up or making sure the crystal doesn’t draft… just synch it up automatically !

WiFly RN-134 just received from Mouser

WiFly connected to PC to check Internet connectivity

WiFly (RN-134) connected to the VFD clock - voltage converter

 

Do note the voltage converter between the two, as the clock microcontroller (AtMega 168) is 5V whereas the WiFly runs at 3.3V !

The Ugly

Everything looked good at this point, but unfortunately this was the beginning of a very frustrating week…

Now let’s have a quick look at what took the longest in this project: setting up the WiFly to make the HTTP requests and download the data…

This board is a great piece of equipment, don’t get me wrong, I love it… however there were some issues and it got very frustrating for a while.

I’ll also mention straight away that the Roving Networks support is great, I’ve never seen such a quick and knowledgeable reply !

In a nutshell, and without going into the numerous possible config details that this board offers I started by trying the obvious thing: use it in “HTTP mode” (set ip proto 18), which is supposed to allow one to simply specify the name of a server and the desired page and then the board will add the required HTTP headers.

Something doesn’t work quite right with this mode (probably adding some extra spaces / new lines) but believe it or not, I have spent an entire week-end trying to debug it…

The convoluted thing was that the same query was working when calling it from the PC (TeraTerm connected to the WiFly board) but would not when it was the AtMega microcontroller sending the commands !

Here are 2 threads with more details:

http://groups.google.com/group/nycresistormicrocontrollers/browse_thread/thread/686b328bc10a8b36

http://groups.google.com/group/london-hack-space/browse_thread/thread/4c40f6abc6dbad74

And by the way, a big THANK YOU to members of both the NYC and London hack spaces for their very valuable help !

Also, from what the roving networks support was saying, the HTTP mode should simply do this:
<remote string><your data><SPACE>HTTP/1.0\nHost:<SPACE><the hostname in config>\n\n

which is what the HTTP standard specifies…

In any case, the solution was to simply go into “TCP mode” (set ip proto 2 , the factory default) and manually construct the HTTP request, as you’ll see in the attached code.

And after a little more frustration, due to the fact that  I had reverted the board to factory defaults and had forgotten to remove the “remote string”, which meant that it kept adding “*HELLO*” to whatever I was sending … lol ,  I got it working!

Again, things look frustratingly simple now, but the very confusing thing with this 2^nd problem was that for some reason the weather.yahooapis.com server would happily work in spite of the extra “*HELLO*” in the request, whereas search.twitter.com would not…

The Beautiful

Code is always beautiful

Here is what I had to add to the basic firmware.

-         wiFly.h & .c – deal with controlling the WiFi board, and constructing the HTTP requests

-         textParser.h & .c– deal with parsing the text or XML outputs from the servers and search for data between 2 tags

-         serialMessages.h & .c – deal with putting all this together and keep track of 3 different connections and parsers, one for each service

-         the few methods that I had to add to the main iv.c code which do the scrolling and periodically call the updates from the servers

-         and finally the util.h & .c files, which are not mine, but I put here because I have done several modifications (don’t dare calling them “improvements” ! )

If you’re really interested and want to replicate this mod without having to put together and compile the code yourself, then let me know and I could definitely send you a HEX file.

_________________________ wiFly.h

/*
 * wiFly.h
 *
 * Created: 17/09/2011 Author: trandi
 */

#ifndef WIFLY_H_
#define WIFLY_H_

#include "util.h"

char wf_httpOpen(const char* server, const char* page);

#endif /* WIFLY_H_ */

_________________________ wiFly.c

/*
 * wiFly.c
 *
 * Created: 17/09/2011 Author: trandi
 */

#include "wiFly.h"
#include "util.h"
#include <util/delay.h>
#include <string.h>

uint8_t findInResponse(const char * str){
	if(uart_waitChar(1000)){
		// wait for the first char
		char ch = uart_getchar();
		while(ch != 0 && ch != str[0]){
			uart_waitChar(300);
			ch = uart_getchar();
		}

		if(ch != 0){
			for(uint8_t offset = 1; offset < strlen(str); offset ++){
				uart_waitChar(300);
				if(uart_getchar() != str[offset]) return 0; // wrong char found
			}

			return 1; // good, found what we were looking for
		}
	}

	// nope, not good....
	return 0;
}

#define CMD(x) uart_emptyReadBuffer();uart_puts_nl(x);

/*
 * Immediately afterwards the response will be available on the serial link !
 * It waits a while for data to come back...
 */
char wf_httpOpen(const char* server, const char* page){
	CMD("exit")
	CMD("close")
	_delay_ms(250);
	uart_puts("$$$"); // enter command mode
	_delay_ms(250);

	CMD("ver")
	if(! findInResponse("WiFly Ver")) return 'v';

	uart_puts("open "); uart_puts(server); uart_puts_nl(" 80");
	if(! findInResponse("*OPEN*")) return 'o';
	uart_puts("GET "); uart_puts(page); uart_puts(" HTTP/1.0\r\nHost: "); uart_puts(server); uart_puts_nl("\r\n");

	return 'n';
}

_________________________ textParser.h

/*
 * textParser.h
 *
 * Created: 15/09/2011 Author: trandi
 */

#ifndef TEXTPARSER_H_
#define TEXTPARSER_H_

#include "util.h"

#define TEXT_DELIM '"'
#define TEXT_SEP '-'

typedef struct {
	const char* server;
	const char* page;
	const char* tagBegin;
	const char* tagEnd;
	uint8_t	useTextDelimiters;
	uint8_t* usedTextIndices;
	uint8_t usedTextIndicesSize;

	uint8_t tagBeginSize;
	uint8_t tagEndSize;
	uint8_t tagBeginPos;
	uint8_t tagEndPos;
	uint8_t currentTextIsValid;
	uint8_t currentTextIndex;

	char msg[MAX_MSG_SIZE];
	uint8_t msgSize;
	char err;
	uint8_t diffCharsCount;
} text_parser_struc;

void tp_init(text_parser_struc* tp, const char* server, const char* page, const char* tagBegin, const char* tagEnd, uint8_t useTextDelimiters, uint8_t* usedTextIndices, uint8_t usedTextIndicesSize);
void tp_start(text_parser_struc* tp);
uint8_t tp_feedChar(text_parser_struc* tp, char newChar);
uint8_t tp_isMsgReady(text_parser_struc* tp);

#endif /* TEXTPARSER_H_ */

_________________________ textParser.c

/*
 * textParser.c
 *
 * Created: 15/09/2011  Author: trandi
 */

#include <avr/pgmspace.h>
#include <string.h>
#include <ctype.h>
#include "textParser.h"

void tp_init(text_parser_struc* tp, const char* server, const char* page, const char* tagBegin, const char* tagEnd, uint8_t useTextDelimiters, uint8_t* usedTextIndices, uint8_t usedTextIndicesSize){
	tp->server = server;
	tp->page = page;
	tp->tagBegin = tagBegin;
	tp->tagEnd = tagEnd;
	tp->useTextDelimiters = useTextDelimiters;
	tp->tagBeginSize = strlen(tagBegin);
	tp->tagEndSize = strlen(tagEnd);

	tp->usedTextIndices = usedTextIndices;
	tp->usedTextIndicesSize = usedTextIndicesSize;

	// default values
	tp->err = 'a';

/*
	uart_puts("Text Parser initialised with: ");
	uart_puts(tagBegin);
	uart_puts(tagEnd);
	uart_puts("\n\r");
*/
}

void tp_start(text_parser_struc* tp){
	tp->tagBeginPos = 0;
	tp->tagEndPos = 0;
	tp->msgSize = 0;
	// if we don't use text delimiters then ALL text inside is valid
	tp->currentTextIsValid = tp->useTextDelimiters ? 0 : 1;
	tp->currentTextIndex = 0;
	tp->diffCharsCount = 0; // assume the message hasn't changed...

	storeChar(tp, TEXT_SEP);storeChar(tp, TEXT_SEP);storeChar(tp, TEXT_SEP);
}

uint8_t tp_isMsgReady(text_parser_struc* tp){
	return ((tp->tagEndPos >= tp->tagEndSize) || (tp->msgSize >= MAX_MSG_SIZE));
}

void storeChar(text_parser_struc* tp, char ch){
	if(ch != tp->msg[tp->msgSize]){
		tp->msg[tp->msgSize] = ch;
		tp->diffCharsCount ++;
	}
	tp->msgSize++;
}

uint8_t tp_feedChar(text_parser_struc* tp, char newChar){
	// can't store anymore chars, no point in continuing !
	if(tp_isMsgReady(tp)) return 1;

	if(tp->tagBeginPos < tp->tagBeginSize){
		// still looking for the beginning tag
		if(newChar == tp->tagBegin[tp->tagBeginPos]){
			tp->tagBeginPos ++;
		}else{
			uint8_t prevPos = tp->tagBeginPos;

			// false hope, wrong tag, start from the beginning
			tp->tagBeginPos = 0;
			// start from the beginning with the latest chars received, which we know are the same as the beginning of _tagBegin. In case there are repetitions in the tag
			for(uint8_t i=1; i<prevPos; i++) tp_feedChar(tp, tp->tagBegin[i]);
		}
	}else if(tp->tagEndPos < tp->tagEndSize){
		if(tp->useTextDelimiters){
			if(tp->currentTextIsValid){
				// in the middle of valid text
				if(TEXT_DELIM == newChar){
					// end of valid text
					tp->currentTextIsValid = 0;
					tp->currentTextIndex ++;
				}else if (tp->usedTextIndices[tp->currentTextIndex]){
					// normal data, store it
					storeChar(tp, newChar);
				}
			}else{
				if(TEXT_DELIM == newChar){
					// beginning of valid text
					tp->currentTextIsValid = 1;
					// add a delimitator with the previous text
					if (tp->usedTextIndices[tp->currentTextIndex]) {
						storeChar(tp, TEXT_SEP);
					}
				}else {
					if(newChar == tp->tagEnd[tp->tagEndPos]){
						// this might be the end
						tp->tagEndPos ++;
						if(tp->tagEndPos >= tp->tagEndSize){
							storeChar(tp, 0); //end of string
						}
					}else{
						uint8_t prevPos = tp->tagEndPos;

						// false hope, wrong tag, start from the beginning
						tp->tagEndPos = 0;
						// start from the beginning with the latest chars received, which we know are the same as the beginning of _tagBegin. In case there are repetitions in the tag
						for(uint8_t i=1; i<prevPos; i++) tp_feedChar(tp, tp->tagEnd[i]);
					}
				}
			}
		}else { //! tp->useTextDelimiters
			if(newChar == tp->tagEnd[tp->tagEndPos]){
				// this might be the end
				tp->tagEndPos ++;
				if(tp->tagEndPos >= tp->tagEndSize){
					storeChar(tp, 0); //end of string
				}
			}else if (tp->tagEndPos > 0) {
				// we thought we started the end tag and actually not...
				uint8_t prevPos = tp->tagEndPos;

				// false hope, wrong tag, start from the beginning
				tp->tagEndPos = 0;
				// start from the beginning with the latest chars received, which we know are the same as the beginning of _tagBegin. In case there are repetitions in the tag
				for(uint8_t i=1; i<prevPos; i++) tp_feedChar(tp, tp->tagEnd[i]);
			}else {
				// normal data, in the middle of the text store it
				storeChar(tp,  newChar);
			}
		}
	}

	// hasn't yet finish, there's only one way of finishing...
	return tp_isMsgReady(tp);
}

_________________________ serialMessages.h

/*
 * serialMessages.h
 *
 * Created: 17/09/2011  Author: trandi
 */

#ifndef SERIALMESSAGES_H_
#define SERIALMESSAGES_H_

typedef struct {
	uint8_t time_s;
	uint8_t time_m;
	uint8_t time_h;
} time_date_struc;

void sm_init(void (*funcSignalUpdt)(void));
time_date_struc* sm_getTime();
char* sm_getMsg(uint8_t switchMode);
void sm_updateTwitter();
void sm_updateWeather();

#endif /* SERIALMESSAGES_H_ */

_________________________ serialMessages.c

/*
 * serialMessages.c
 *
 * Created: 16/09/2011 Author: trandi
 */

#include <util/delay.h>
#include "serialMessages.h"
#include "util.h"
#include "textParser.h"
#include "wiFly.h"
#include <stdlib.h>

static char ERR[] = {'e', 'r', 'r', ' ', ' ', ' ', ' ', ' ', 0};
#define setErr(x, y) ERR[4] = x; ERR[5] = y

static uint8_t UTI_YAHOO_WEATHER[] = {1, 0, 1, 1, 1, 0};
static uint8_t UTI_TWITTER[] = {1};

text_parser_struc _yahooWeatherParser;
text_parser_struc _twitterParser;
text_parser_struc _timeParser;
time_date_struc _timeDate;

// pointer to the function to call when we receive a new message
void (*funcSignalUpdate)(void);

uint8_t _mode = 0; // 0 - weather, 1 - twitter

void sm_init(void (*funcSignalUpdt)(void)){
	funcSignalUpdate = funcSignalUpdt;

	tp_init(&_yahooWeatherParser,
			"weather.yahooapis.com",
			"/forecastrss?w=44418&u=c",  // London, in Celsius
			"<yweather:forecast",	// tag begin
			"/>",					// tag end
			1,						// do use the '"' values delimiters, next params are used
			UTI_YAHOO_WEATHER,		// which bits of text to use
			6						// how many bits have we defined
	);

	tp_init(&_twitterParser,
			"search.twitter.com",
			"/search.json?q=arduino&rpp=1",
			"\"text\"",				// tag begin
			"\"to_user_id\"",		// tag end
			1,						// 0 if we wanted NO '"' text delimiters, next 2 params are ignored !
			UTI_TWITTER,			// which bits of text to use
			1	// how many bits have we defined
	);

	tp_init(&_timeParser,
			"www.timeanddate.com",
			"/worldclock/city.html?n=136",
			"=big>",				// tag begin
			"</strong>",			// tag end
			0,						// 0 if we wanted NO '"' text delimiters, next 2 params are ignored !
			0,			// which bits of text to use
			0	// how many bits have we defined
	);
}

void getSerialMsg(text_parser_struc* tp){
	tp->err = '1';
	if(uart_waitChar(3000)){ // be generous with the initial wait !
		tp_start(tp);

		while(uart_waitChar(1000) && ! tp_feedChar(tp, uart_getchar()));
		tp->err = '2';

		if(tp_isMsgReady(tp)) tp->err = 'n'; // everything ok

		// the message is done, but empty the buffer
		uart_emptyReadBuffer();
	}
}

char* sm_getMsg(uint8_t switchMode){
	if(switchMode){
		_mode = ! _mode;
	}

	if(_mode){
		setErr('y', _yahooWeatherParser.err);
		return _yahooWeatherParser.err == 'n' ? _yahooWeatherParser.msg : ERR;
	}else{
		setErr('w', _twitterParser.err);
		return _twitterParser.err == 'n' ? _twitterParser.msg : ERR;
	}
}

void sm_updateTwitter(){
	_twitterParser.err = wf_httpOpen(_twitterParser.server, _twitterParser.page);
	if(_twitterParser.err == 'n') {
		getSerialMsg(&_twitterParser);

		// call the signal only if there are at least 10 different chars. For some reason there can be small diffs in messages...
		if(_twitterParser.diffCharsCount > 10){
			_twitterParser.diffCharsCount = 0;
			funcSignalUpdate();
		}
	}
}

void sm_updateWeather(){
	_yahooWeatherParser.err = wf_httpOpen(_yahooWeatherParser.server, _yahooWeatherParser.page);
	if(_yahooWeatherParser.err == 'n') {
		getSerialMsg(&_yahooWeatherParser);
	}
}

time_date_struc* sm_getTime(){
	_timeParser.err = wf_httpOpen(_timeParser.server, _timeParser.page);
	if(_timeParser.err == 'n') {
		getSerialMsg(&_timeParser);

		// the msg should be something like Saturday, "24 September 2011, 09:31:40 " extract hours and minutes
		char num[2];
		num[0] = _timeParser.msg[_timeParser.msgSize - 9];
		num[1] = _timeParser.msg[_timeParser.msgSize - 8];
		_timeDate.time_h = atoi(num);
		num[0] = _timeParser.msg[_timeParser.msgSize - 6];
		num[1] = _timeParser.msg[_timeParser.msgSize - 5];
		_timeDate.time_m = atoi(num);
		num[0] = _timeParser.msg[_timeParser.msgSize - 3];
		num[1] = _timeParser.msg[_timeParser.msgSize - 2];
		_timeDate.time_s = atoi(num);
	}else{
		setErr('t', _timeParser.err);
		_timeDate.time_h = 0; _timeDate.time_m = 0; _timeDate.time_s = 0;
	}

	return &_timeDate;
}

_________________________ util.h

#ifndef UTIL_H_
#define UTIL_H_

//BRR = (F_CPU / 16 / BaudRate ) - 1
#if (F_CPU == 16000000)
#define BRRL_2400 416    // for 16MHZ
#define BRRL_9600 103    // for 16MHZ
#define BRRL_19200 52    // for 16MHZ
#define BRRL_115200 8
#elif (F_CPU == 8000000)
#define BRRL_2400 207
#define BRRL_9600 52
#define BRRL_19200 26
#define BRRL_115200 3
#endif

#include <inttypes.h>

// very tricky, uses a lot of space !
// for some reason IF this gets too big and the "Data" part of the program goes beyond 90%,
// the text parser for yahoo weather doesn't work anymore... don't ask WHY !? :)
#define MAX_MSG_SIZE 60

//void delay_ms(unsigned char ms);
void delay_10us(uint8_t us);
void delay_s(uint8_t s);

int uart_putchar(unsigned char c);
void uart_init(uint16_t BRR);

unsigned char uart_getchar(void);
uint8_t uart_isCharAvailable(void);
void uart_emptyReadBuffer(void);
uint8_t uart_waitChar(uint16_t timeoutMs);

void uart_putc_hex(uint8_t b);
void uart_putw_hex(uint16_t w);
void uart_putdw_hex(uint32_t dw);

void uart_putw_dec(uint16_t w);
void uart_putdw_dec(uint32_t dw);
void uart_puts(const char* str);

void RAM_putstring(char *str);
void ROM_putstring(const char *str, uint8_t nl);

#define uart_puts_nl(x) uart_puts(x);uart_puts("\r\n")

#define putstring(x) ROM_putstring(PSTR(x), 0)
#define putstring_nl(x) ROM_putstring(PSTR(x), 1)

#define NOP asm("nop");
#define nop asm volatile ("nop\n\t")

#endif /* UTIL_H_ */

_________________________ util.c

/***************************************************************************
 Ice Tube Clock firmware August 13, 2009
 (c) 2009 Limor Fried / Adafruit Industries
  Modified by Tr@ndi

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#include "util.h"

void delay_10us(uint8_t ns)
{
  uint8_t i;

  while (ns != 0) {
    ns--;
    for (i=0; i< 30; i++) {
      nop;
    }
  }
}

void delay_s(uint8_t s) {
  while (s--) {
    _delay_ms(1000);
  }
}

// setup the main UART
void uart_init(uint16_t BRR) {
  UBRR0 = BRR;               // set baudrate counter

  UCSR0B = _BV(RXEN0) | _BV(TXEN0);  // Enable receiver and transmitter
  UCSR0C = 3<<UCSZ00;  // Frame format: 8data, No parity, 1stop bit
  DDRD |= _BV(PD1);
  DDRD &= ~_BV(PD0);

}

int uart_putchar(unsigned char c)
{
  loop_until_bit_is_set(UCSR0A, UDRE0);
  UDR0 = c;
  return 0;
}

unsigned char uart_getchar(void) {
	//if (uart_isCharAvailable())
	return UDR0;
	//return 0;
}

uint8_t uart_isCharAvailable(void) {
	return (UCSR0A & _BV(RXC0));
}

void uart_emptyReadBuffer(void){
	char ch;
	while(uart_waitChar(100)) ch = uart_getchar();
}

uint8_t uart_waitChar(uint16_t timeoutMs){
	for(uint16_t i=0; i<timeoutMs && !uart_isCharAvailable(); i++) _delay_ms(1);
	return uart_isCharAvailable();
}

void ROM_putstring(const char *str, uint8_t nl) {
    for (uint8_t i=0; pgm_read_byte(&str[i]); i++) {
        uart_putchar(pgm_read_byte(&str[i]));
	}
	if (nl) {
		uart_putchar('\n'); uart_putchar('\r');
	}
}

void uart_puts(const char* str)
{
    while(*str){
        uart_putchar(*str++);
	}
}

void uart_putc_hex(uint8_t b)
{
    /* upper nibble */
    if((b >> 4) < 0x0a)
        uart_putchar((b >> 4) + '0');
    else
        uart_putchar((b >> 4) - 0x0a + 'a');

    /* lower nibble */
    if((b & 0x0f) < 0x0a)
        uart_putchar((b & 0x0f) + '0');
    else
        uart_putchar((b & 0x0f) - 0x0a + 'a');
}

void uart_putw_hex(uint16_t w)
{
    uart_putc_hex((uint8_t) (w >> 8));
    uart_putc_hex((uint8_t) (w & 0xff));
}

void uart_putdw_hex(uint32_t dw)
{
    uart_putw_hex((uint16_t) (dw >> 16));
    uart_putw_hex((uint16_t) (dw & 0xffff));
}

void uart_putw_dec(uint16_t w)
{
    uint16_t num = 10000;
    uint8_t started = 0;

    while(num > 0)
    {
        uint8_t b = w / num;
        if(b > 0 || started || num == 1)
        {
            uart_putchar('0' + b);
            started = 1;
        }
        w -= b * num;

        num /= 10;
    }
}

void uart_putdw_dec(uint32_t dw)
{
    uint32_t num = 1000000000;
    uint8_t started = 0;

    while(num > 0)
    {
        uint8_t b = dw / num;
        if(b > 0 || started || num == 1)
        {
            uart_putchar('0' + b);
            started = 1;
        }
        dw -= b * num;

        num /= 10;
    }
}

_________________________ ADDED this bit AT THE END of iv.c

#define SCROLL_SPEED 200				// milliseconds
#define TIME_MSG_MODES_SWITCH_SPEED 15000   // milliseconds
#define TIME_MSG_TIME_UPDATE 3600	// seconds
#define TIME_MSG_WEATHER_UPDATE 3600	// seconds
#define TIME_MSG_TWITTER_UPDATE 60		// seconds

// only beeps if the alarm is on, so that we can control the stuff...
void myBeep() {
	if(alarm_on){
		beep(1500, 1);beep(3500, 1);beep(5000, 1);
	}
}

// Scrolling of the message.
void scrollMsg(){
	// Move the text
	uint8_t firstElem = display[1];
	for(uint8_t i = 1; i < _msgSize; i++) display[i] = display[i+1];
	display[_msgSize] = firstElem;
}

// alternate between SHOW_TIME and SHOW_MSG
void alternateTimeMsgModes(){
	//tick();
	if(displaymode == SHOW_TIME){
		displaymode = SHOW_MSG;
		display_str(sm_getMsg(1));
	}else if(displaymode == SHOW_MSG){
		displaymode = SHOW_TIME;
		_msgSize = 0; //stop scrolling !
	}
}

void updateTime(){
	time_date_struc* timeDate_s = sm_getTime();
	time_h = timeDate_s->time_h;
	time_m = timeDate_s->time_m;
	time_s = timeDate_s->time_s;
}

// called from an interrupt, every millisecond, for short and vital tasks
void customInterruptPeriodicActions(){
	if(_msgSize >= DISPLAYSIZE && _myMillisCounter %  SCROLL_SPEED == 0) scrollMsg();
	if(_myMillisCounter % TIME_MSG_MODES_SWITCH_SPEED == 0) alternateTimeMsgModes();
}

uint16_t _lastPeriodicActionSecs = 0;
// called from the main loop, for LONGER running tasks
void customPeriodicActions(){
	// don't even do the next calculations if the seconds have not changed
	if(_lastPeriodicActionSecs != _mySecondsCounter){
		if(_mySecondsCounter % TIME_MSG_TIME_UPDATE == 0) updateTime();

		if(_mySecondsCounter % TIME_MSG_TWITTER_UPDATE == 0) sm_updateTwitter();
		if(_mySecondsCounter % TIME_MSG_WEATHER_UPDATE == 0) sm_updateWeather();

		_lastPeriodicActionSecs = _mySecondsCounter;
	}

In iv.c, the 2 methods that “inject” my mod into the rest of the code are

• customPeriodicActions(), called at the beginning of the infinite look within the main() method
• and customInterruptPeriodicActions(), called in the middle of SIGNAL (SIG_OVERFLOW0) {} which occurs roughly every millisecond

WiFi VFDClock Finished

 

And here is the final photo, installed in its rightful place, along my collection of miniature single malts

 

WiFi VFDClock Final Position

 

As usual, if you’ve made it up to here and had the patience to read all my ramblings, then don’t hesitate to leave a commend and give some feedback…

VFD IV-18 Clock Finished and working

This week’s post is about my first attempt at (yet another ) VFD based clock.

Given that I’m really no expert in vacuum tubes I have simply chosen to go with a kit. I don’t know if there are many types out there, but ladyada’s one, seemed really nicely done, reasonably priced and very very well documented.

Here’s the final result, for those that can’t be bothered with reading through the assembling and testing…

I ordered the kit from the German website Watterott, which is far cheaper that the options here in the UK (about 20%) and I’m quite happy with their speedy delivery and service.

Here are the various parts:

IV-18 VFD Clock electronic parts

VFD Clock - the IV-18 vacuum tube itself

I followed Ladyada’s tutorial and the soldering was really easy and quick (I really like the fact that she explains the role of almost each component and how they fit together, not simply how to solder !)…

IV-18 VFD Clock - half way through assembly

Also, you get to test each of the 3 parts of the circuit:

1. the 5V power supply on the left
2. the microcontroller and its watch crystal in the middle
3. the high voltage boost supply on the right (the VFD tube needs around 50V to light up)

Then came the hardest bit of the process, inserting and then soldering the VFD tube itself:

IV-18 VFD Clock inserting the tube

IV-18 VFD Clock soldering the vacuum tube

Luckily enough everything went smoothly (especially the tube positioning, which can’t really be fixed if done wrong the first time !) and the final test seems successful :

VFD Clock - final test

That’s it ! No code today, as the Atmega168 microcontroller comes pre-programmed, and the kit is really complete, even with the back-up battery !

However, I’m planning on hacking this clock (even if it required some soldering it felt too easy… ) and make it connect to other “stuff” and display some custom messages for example… so stay tuned !

While away I have received the eZ430 Chronos Development Tool / Watch from Texas Instruments (have I ever mentioned how great their service is, how quick and free the delivery, etc. … !? ) and therefore had to put aside my Android / IOIO related projects, and delve into this new gadget !

1. First impressions

TI eZ430 Watch Box

The packaging looks good, as good or even better than “real” watches… !

TI eZ430 Watch opened box

TI eZ430 Watch box contents

The contents are quite impressive, and TI seems to be taking these eval kits quite seriously : not only they include the USB programmer / debugger and an USB wireless access point for remote communication, but even a screwdriver and a couple of spare screws…

Have I mentioned that this kit costed me only 25$ (on sale from the original 50$) including free shipping to the UK !?  I know it’s all about advertising their products, but still… THANK YOU TI, this is a lot of stuff for ~ 15£ !

Now let’s get down to business and try to program this “beast”…

2. Connect the hardware

This is quite easy, and here’s how it looks with the internals exposed:

TI eZ430 Watch Internals

And now connected to the USB programmer / debugger :

TI eZ430 Watch Connected to the PC

3. Software environment

Now the hard stuff commences…

First look at the “Sports Watch” code (basically the firmware that the watch comes with) reminds me why I’m a Java programmer by trade…

Then I install the IAR development environment and all of a sudden memories from high school rush back to my mind… haven’t these guys notices we’re in 2011 !

I can’t even seem to be able to open an existing project… lol…

I try Code Composer Studio… much better, Eclipse based… Java rocks indeed, at least for the IDE !

Code Composer Studio - TI eZ430

Ok, I know that I’m just a newbie when it comes to embedded electronics and that IAR is probably one of the best tools out there, but hey I want to have fun, I’m not paid to do this ! It’s enough that I have to program these little marvels in C and that even the slightest string manipulation takes 5 lines of code, I want to enjoy my hobby !

One issue worth nothing is also the general slowness of both the compilation and the download of the firmware to the eZ430. It takes around 1min 20secs even for the slightest change to get re-compiled and transfered over.

4. My first program

All I want to do is create a new mode on the watch that simply displays “Hello World”. To make things slightly more complex, and because there are not enough digits, I want the text to scroll.

I struggle a couple of hours on a Friday night but finally start to appreciate TI’s code… it’s quite clean and well organised, in some sort of state machine.  All I need to do is replicate the already existing code for the “acceleration” mode (the one that periodically reads the accelerometer chip and displays the values on the screen).

1. the code for the new MODULE

The HEADER - trandi.h

#ifndef TRANDI_H_
#define TRANDI_H_

// ******************************************
// Defines section
#define TRANDI_MODE_OFF		(0u)
#define TRANDI_MODE_ON		(1u)

// ******************************************
// Global Variable section
struct trandi
{
	// TRANDI_MODE_OFF, TRANDI_MODE_ON
	u8			mode;
	// Data to display
	u8  		msg[20];
};
extern struct trandi sTrandi;

// ******************************************
// Extern section
extern void reset_trandi(void);
extern void sx_trandi(u8 line);
extern void display_trandi(u8 line, u8 update);
extern u8 is_trandi_active(void);
extern void do_trandi_random(void);

#endif /*TRANDI_H_*/

The IMPLEMENTATION – trandi.c

// ******************************************
// Include section

// system
#include "project.h"

// driver
#include "display.h"
#include "vti_as.h"

// logic
#include "trandi.h"
#include "simpliciti.h"
#include "user.h"
#include "string.h"

// ******************************************
// Global Variable section
struct trandi sTrandi;

// ******************************************
// Extern section

// ******************************************
// @fn          reset_trandi
// @brief       Reset / INIT trandi data.
// @param       none
// @return      none
// ******************************************
void reset_trandi(void)
{
	// Reset state is not active
	sTrandi.mode = TRANDI_MODE_OFF;

	strcpy(sTrandi.msg, (u8*)"TRANDI HELLO WORLD  ");
}

// ******************************************
// @fn          sx_trandi
// @brief       Button UP does nothing for now...
// @param       u8 line		LINE2
// @return      none
// ******************************************
void sx_trandi(u8 line)
{

}

// ******************************************
// @fn          display_trandi
// @brief       Display routine.
// @param       u8 line			LINE1
//		u8 update		DISPLAY_LINE_UPDATE_FULL, DISPLAY_LINE_CLEAR
// @return      none
// ******************************************
void display_trandi(u8 line, u8 update)
{
	if (update == DISPLAY_LINE_UPDATE_FULL)
	{
		display_chars(LCD_SEG_L1_3_0, sTrandi.msg, SEG_ON);
		display_symbol(LCD_ICON_HEART, SEG_ON_BLINK_ON);

		// Set mode
		sTrandi.mode = TRANDI_MODE_ON;
	}
	else if (update == DISPLAY_LINE_UPDATE_PARTIAL)
	{
		display_chars(LCD_SEG_L1_3_0, sTrandi.msg, SEG_ON);
	}
	else if (update == DISPLAY_LINE_CLEAR)
	{
		display_symbol(LCD_ICON_HEART, SEG_OFF);

		reset_trandi();
	}
}

// ******************************************
// @fn          is_trandi_active
// @brief       Returns 1 if trandi module is currently active and needs doing random stuff.
// @param       none
// @return      u8		1 = trandi module needs random stuff
// ******************************************
u8 is_trandi_active(void)
{
	return sTrandi.mode == TRANDI_MODE_ON;
}

void do_trandi_random(void)
{
	// Move the text
	u8 firstElem = sTrandi.msg[0];
	u8 len = sizeof(sTrandi.msg) / sizeof(u8);
	u8 i;
	for(i = 0; i < len - 1; i++) sTrandi.msg[i] = sTrandi.msg[i+1];
	sTrandi.msg[len - 1] = firstElem;

	// Set display update flag
	display.flag.update_trandi = 1;
}

2. modify the main MENU

In the menu.c define this new structure

// Line1 - Trandi secret function
const struct menu menu_L1_Trandi =
{
	FUNCTION(sx_trandi),				// direct function
	FUNCTION(dummy),					// sub menu function
	FUNCTION(display_trandi),			// display function
	FUNCTION(update_trandi),			// new display data
	&menu_L1_Alarm,
};
u8 update_trandi(void)
{
	return (display.flag.update_trandi);
}

Add it to the chain of L1 menus, after the “Time” one, like so:

const struct menu menu_L1_Time =
{
	FUNCTION(sx_time),			// direct function
	FUNCTION(mx_time),			// sub menu function
	FUNCTION(display_time),		// display function
	FUNCTION(update_time),		// new display data
	&menu_L1_Trandi,
};

3. modify the MAIN logic

In main.c , update init_global_variables() with a pointer to the new menu (if we want it to be displayed by default) and a call to reset_trandi().

void init_global_variables(void)
{
	// --------------------------------------------
	// Apply default settings

	// set menu pointers to default menu items
//	ptrMenu_L1 = &menu_L1_Time;
	ptrMenu_L1 = &menu_L1_Trandi;
//	ptrMenu_L1 = &menu_L1_Alarm;
//	ptrMenu_L1 = &menu_L1_Heartrate;
...................
	// Reset acceleration measurement
	reset_acceleration();

	// Reset / init trandi stuff
	reset_trandi();

	// Reset BlueRobin stack
	reset_bluerobin();
}

Also add if (request.flag.trandi) do_trandi_random(); in process_requests().

4. update the TIMER calls to enable scrolling

There’s plenty of stuff in timer.c and we need to add a trigger on one of the periodic events, so that the trandi module gets “woken up” periodically and moves the custom string left.

Initially timer.c is EXCLUDED from the build, simply because I’m using the Core Edition of CSS which limits the max size of the code compiled (have I told you how much I love Arduino and the Open Source community !? ). However I could easily add back this file to be compiled with the others, without going beyond the limit … hooray…

In TIMER0_A0_ISR() (this is called every second which is really what we want !):

	// Send a signal / do some random stuff every second on Trandi, WHEN enabled
	if (is_trandi_active())
	{
		request.flag.trandi = 1;
	}

	// If BlueRobin transmitter is connected, get data from API
	if (is_bluerobin()) get_bluerobin_data();

And that’s it ! The text “TRANDI HELLO WORLD” scrolls on the L1 display ! (notice that understandably there’s no easy way to fit a “W” in a 7 segments digit, so it’s not displayed correctly, I get a “-” instead…lol..;) )

At the end of the day, it’s not terribly complex, it works and it took me only about half a day to get here…

If you’re reading this, then thank you for your patience and interest, and please don’t forget to leave your feedback which would be more than appreciated !

Wii Motion Plus connected to the IOIO board and then to the Android phone

Today I took some time to set up wireless debugging, in order to be able to see the logs at the same time as the phone is connected through USB to the IOIO board. This was not a big issue for very simple programs, but it can quickly become veeery annoying !

As mentioned on this forum topic having a SSHd server running on the Android device and connecting through WiFi to it from the dev PC is a neat solution.

The best part is that I didn’t have to spend too much time following this kind of complex tutorial. Here’s my approach:

1. root the phone (was already like this, and lucky me I had bought it like this on eBay)
2. BUSYBOX – can be installed from the Android market for free
3. Install QuickSSHd (based on dropbear) from Android market for 0.99£ (I know, some people prefer software that is free like in free beer, and I think there are actually some other ads based versions out there, but I couldn’t be bothered)
4. and that’s it: you can uyse Putty or WinSCP to connect to your phone and transfer files

Not only this allows me to do “logcat” remotely on the phone while it’s connected to the IOIO board, but I can also SCP the “.adk” files and install them manually, allowing me to basically NEVER disconnect it from the IOIO board.

This is AWESOME !

Now back to the main subject of the post…

I basically want to transform the phone into a proper IMU, but it lacks gyroscopes. It already has accelerometers and compasses, but gyros are vital if we want to have any accuracy…

So what better solution than try to attach a Wii Motion Plus (containing 3 nice gyros, all conveniently exposed through a I2C interface) … ? The idea is to do something similar to this Arduino connection, but with the smart phone, through the IOIO board.

Here are the details of the wiring, basically the same thing as for the Wii Nunchuck, the differences are in the code.

Wii Motion Plus - details of the wiring to the IOIO board

And finally, the Java / Android code:

IOIOWiiMotionPlus.java
-------------------------------------------------------
package com.trandi.wii;

import ioio.lib.api.TwiMaster;
import ioio.lib.api.exception.ConnectionLostException;
import android.util.Log;

public class IOIOWiiMotionPlus {

private TwiMaster _twi;
// 7bit addressing
private static final int WII_WMP_ADDR_INIT = 0x53;
private static final int WII_WMP_ADDR = 0x52;
private final byte[] _dataBuffRaw = new byte[6];// array to store nunchuck data
private final int[] _dataBuff = new int[6];
private int _gyroX0, _gyroY0, _gyroZ0; //calibration zeroes
private int _gyroX, _gyroY, _gyroZ;

public boolean init(TwiMaster twi) throws ConnectionLostException, InterruptedException {
_twi = twi;

if(!initGyros()) {
Log.w(Util.LOG_TAG, "Can't INTIALIZE Gyros. This might be normal if they are already initialized and the WMP hasn't been turned off.");
}
if(! calibrateGyrosZeroes()) {
Log.e(Util.LOG_TAG, "Can't CALIBRATE Gyros");
return false;
}
return true;
}

private boolean initGyros() throws ConnectionLostException, InterruptedException {
// We don't care about what the WMP returs, but we need to provide a buffer to avoid a
// java.lang.NullPointerException
// E/WII     ( 1164):      at java.lang.System.arraycopy(Native Method)
// E/WII     ( 1164):      at ioio.lib.impl.TwiMasterImpl.dataReceived(TwiMasterImpl.java:141)
boolean res = _twi.writeRead(WII_WMP_ADDR_INIT, false, new byte[]{(byte)0xFE, 0x04}, 2, _dataBuffRaw, 0);
Thread.sleep(10);
return res;
}

public boolean readData() throws ConnectionLostException, InterruptedException {
// Send a request for data and read raw data
if( _twi.writeRead(WII_WMP_ADDR, false, new byte[]{0x00}, 1, _dataBuffRaw, _dataBuffRaw.length)){
for(int i=0; i<_dataBuffRaw.length; i++) _dataBuff[i] = Util.fixJavaByte(_dataBuffRaw[i]);

//see http://wiibrew.org/wiki/Wiimote/Extension_Controllers#Wii_Motion_Plus for info on what each byte represents
_gyroZ = ((_dataBuff[3] >> 2) << 8) + _dataBuff[0] - _gyroZ0;
_gyroX = ((_dataBuff[4] >> 2) << 8) + _dataBuff[1] - _gyroX0;
_gyroY = ((_dataBuff[5] >> 2) << 8) + _dataBuff[2] - _gyroY0;

return true;
}

return false;
}


private boolean calibrateGyrosZeroes() throws ConnectionLostException, InterruptedException {
long tempX=0, tempY=0, tempZ=0;
_gyroX0 = 0; _gyroY0 = 0; _gyroZ0 = 0;
for (int i=0; i<10; i++){
if (! readData()) return false;

tempZ += _gyroZ;
tempX += _gyroX;
tempY += _gyroY;

Thread.sleep(10);
}

// average 10 readings
_gyroZ0 = (int)(tempZ / 10);
_gyroX0 = (int)(tempX / 10);
_gyroY0 = (int)(tempY / 10);

return true;
}



public int getGyroX() {
return _gyroX;
}

public int getGyroY() {
return _gyroY;
}

public int getGyroZ() {
return _gyroZ;
}
}





MainActivity.java
-------------------------------------------------------
package com.trandi.wii;

import ioio.lib.api.PwmOutput;
import ioio.lib.api.TwiMaster;
import ioio.lib.api.exception.ConnectionLostException;
import ioio.lib.util.AbstractIOIOActivity;

import java.lang.Thread.UncaughtExceptionHandler;

import android.os.Bundle;
import android.util.Log;
import android.widget.FrameLayout;
import android.widget.TextView;


public class MainActivity extends AbstractIOIOActivity {
private TextView _varField;
private TextView _msg;
private FrameLayout _drawingFrame;
private Ball _ball;

/**
* Called when the activity is first created. Here we normally initialize our GUI.
*/
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
@Override
public void uncaughtException(Thread thread, Throwable ex) {
Log.e(Util.LOG_TAG, "", ex);
}
});

setContentView(R.layout.main);
_varField = (TextView) findViewById(R.id.textViewVarVal);
_msg = (TextView) findViewById(R.id.textViewMsg);

_drawingFrame = (FrameLayout) findViewById(R.id.drawingFrame);
_ball = new Ball(_drawingFrame.getContext(), 15);
_drawingFrame.addView(_ball);
}


/**
* 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 {
private final IOIOWiiMotionPlus _wmp = new IOIOWiiMotionPlus();
private PwmOutput _led; // The on-board LED
private boolean _ledOn = false;



/**
* Called every time a connection with IOIO has been established.
* Typically used to open pins.
*
* @throws ConnectionLostException When IOIO connection is lost.
*/
@Override
protected void setup() throws ConnectionLostException {
try {
_led = ioio_.openPwmOutput(0, 300);
_led.setDutyCycle(0);

// initialize the I2C system, join the I2C bus,
TwiMaster twi = ioio_.openTwiMaster(0, TwiMaster.Rate.RATE_100KHz, false);
if(! _wmp.init(twi)) throw new Exception("Can't initialise WMP");
} catch (Exception e) {
msg(e);
}
}

/**
* Called repetitively while the IOIO is connected.
*
* @throws ConnectionLostException When IOIO connection is lost.
*/
@Override
protected void loop() throws ConnectionLostException {
try {
if(_wmp.readData()) {
_ball.setPos(mapPos(_wmp.getGyroX()), mapPos(_wmp.getGyroY()));

runOnUiThread(new Runnable() {
@Override
public void run() {
_varField.setText(_wmp.getGyroX() + "  " + _wmp.getGyroY() + "  " + _wmp.getGyroZ());
refreshBall();
}
});

_led.setDutyCycle(_ledOn ? 1 : 0);
_ledOn = ! _ledOn;

Thread.sleep(100);
}
} catch (Exception e) {
msg(e);
}
}
}

private static int mapPos(int value) {
return 150 + value / 30;
}

private void msg(Throwable e){
msg("ERR: " + e.getMessage());
}

private void refreshBall() {
runOnUiThread(new Runnable() {
@Override
public void run() {
_drawingFrame.removeView(_ball);
_drawingFrame.addView(_ball);
}
});
}

private void msg(final String msg){
runOnUiThread(new Runnable() {
@Override
public void run() {
_msg.setText("MSG:  " + msg);
}
});
}

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




Util.java
-------------------------------------------------------
package com.trandi.wii;

public class Util {
static final String LOG_TAG = "WII";

/**
* Transforms a 0..127 -128 .. 0 range into a 128..0..-128 one
*/
static int fixJavaByte(byte init){
int result = init;
boolean negative = result < 0;
if(negative) result = -result;
result = - result + 128;
if(negative) result = -result;
return result;
}
}




Ball.java
-------------------------------------------------------
package com.trandi.wii;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.view.View;

public class Ball extends View {
private float x = 0;
private float y = 0;
private final int r;
private final Paint mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);

public Ball(Context context, int r) {
super(context);
mPaint.setColor(0xFFFF0000);
this.r = r;
}

public void setPos(float x, float y) {
this.x = x;
this.y = y;
}

@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
canvas.drawCircle(x, y, r, mPaint);
}
}

A few things / tricky bits worth mentioning:

• when calling TwiMaster.writeRead() you HAVE to provide an output buffer IF the slave will output something (EVEN IF you don’t care about it and the output read size is 0)
• the Util.fixJavaByte() is important because in Java bytes are signed whereas in C they are not
• also notice the 2 addresses that the WMP uses: one for the init and the other one for the subsequent requests

The problem that I have is that the TWI library on the IOIO doesn’t time out if there’s no slave listening at the indicated address. This means that if I call init() and the WMP is already initialised, it will hang forever…

It’s only fair that I explore the same thing with an Android phone and the IOIO board.

The IOIO board is great !

I’ve already done a quick Hello World project, and a slightly more advanced one, controlling a RC Servo.

I’m keen on testing the I2C features… and what better way than trying to connect a Wii peripheral to the board !?

The Wii Nunchuck I’m using has had it’s PULL-UP resistors removed, because they were of quite low value and the Lego NXT couldn’t cope with it.

So now I’m using two2 2.2kOhms ones, connected directly from the Data and Clock lines to 3.3V.

The IOIO board works at 3.3V so this is perfect for the nunchuck.

Here’s an image of the wiring, using the Nunchucky 1.0 adapter from Solarbotics :

Wii Nunchuck connected to the IOIO board - Nunchucky 1.0 adapter from Solarbotics

And here is the whole project:

Android phone + IOIO board + Wii Nunchuck + Battery

Once you the data from the nunchuck is retrieved on the Android device, one can obviously do plently of useful things with it, but in my case I’ve just quickly put together a very basic 2D animation, that simply moved a red ball according to the nunchuck’s joystick:

Android IOIO - Wii Nunchuck - 2D animation

And here is the Android Code

First, the IOIONunchack class, that connects through I2C and does the data decoding:

package com.trandi.wiinunchuck;

import ioio.lib.api.IOIO;
import ioio.lib.api.TwiMaster;
import ioio.lib.api.exception.ConnectionLostException;

public class IOIONunchuck {
private int joy_x_axis;
private int joy_y_axis;
private int accel_x_axis;
private int accel_y_axis;
private int accel_z_axis;
private boolean z_button = false;
private boolean c_button = false;

private TwiMaster _twi;
private static final int WII_NUN_ADDR = 0x52;  // 7bit addressing.  It would be 0xA4 in 8bit
private static final int WII_NUN_MEM_ADDR = 0x40;
private final byte[] _dataBuff = new byte[6];// array to store nunchuck data

public boolean init(IOIO ioio) throws ConnectionLostException, InterruptedException {
// initialize the I2C system, join the I2C bus,
_twi = ioio.openTwiMaster(0, TwiMaster.Rate.RATE_100KHz, false);

// tell the nunchuck we're talking to it
return _twi.writeRead(WII_NUN_ADDR, false, new byte[]{WII_NUN_MEM_ADDR, 0x00}, 2, new byte[]{}, 0);
}

public boolean readData() throws ConnectionLostException, InterruptedException {
if(readRawData()){
for(int i=0; i<_dataBuff.length; i++) _dataBuff[i] = nunchuckDecodeByte(_dataBuff[i]);

// transform into something meaningful
joy_x_axis = _dataBuff[0];
joy_y_axis = _dataBuff[1];
accel_x_axis = _dataBuff[2];
accel_y_axis = _dataBuff[3];
accel_z_axis = _dataBuff[4];

// byte nunchuck_buf[5] contains bits for z and c buttons
z_button = (_dataBuff[5] & 0x01) == 0;
c_button = (_dataBuff[5] & 0x02) == 0;

// it also contains the least significant bits for the accelerometer data so we have to check each bit of byte outbuf[5]
if ((_dataBuff[5] & 0x03) > 0) accel_x_axis += 2;
if ((_dataBuff[5] & 0x04) > 0) accel_x_axis += 1;

if ((_dataBuff[5] & 0x05) > 0) accel_y_axis += 2;
if ((_dataBuff[5] & 0x06) > 0) accel_y_axis += 1;

if ((_dataBuff[5] & 0x07) > 0) accel_z_axis += 2;
if ((_dataBuff[5] & 0x08) > 0) accel_z_axis += 1;

joy_x_axis = updateRange(joy_x_axis);
joy_y_axis = updateRange(joy_y_axis);
accel_x_axis = updateRange(accel_x_axis);
accel_y_axis = updateRange(accel_y_axis);
accel_z_axis = updateRange(accel_z_axis);

return true;
}

return false;
}

private boolean readRawData() throws ConnectionLostException, InterruptedException {
// 1. Send a request for data to the nunchuck
if(_twi.writeRead(WII_NUN_ADDR, false, new byte[]{0x00}, 1, _dataBuff, 0)) {

Thread.sleep(10);

// 2. read data
return _twi.writeRead(WII_NUN_ADDR, false, new byte[]{}, 0, _dataBuff, _dataBuff.length);
}

return false;
}

/**
* Transforms a 0..127 -128 .. 0 range into a 128..0..-128 one
*/
private static int updateRange(int init){
int result = init;
boolean negative = result < 0;
if(negative) result = -result;
result = - result + 128;
if(negative) result = -result;
return result;
}

private byte nunchuckDecodeByte (byte x){
return (byte)((x ^ 0x17) + 0x17);
}

public int getJoy_x_axis() {
return joy_x_axis;
}

public int getJoy_y_axis() {
return joy_y_axis;
}

public int getAccel_x_axis() {
return accel_x_axis;
}

public int getAccel_y_axis() {
return accel_y_axis;
}

public int getAccel_z_axis() {
return accel_z_axis;
}

public boolean isZ_button() {
return z_button;
}

public boolean isC_button() {
return c_button;
}
}

Then, the MainActivity and the Ball classes, that do all the Android plubing :

______________ MainActivity.java

package com.trandi.wiinunchuck;

import ioio.lib.api.PwmOutput;
import ioio.lib.api.exception.ConnectionLostException;
import ioio.lib.util.AbstractIOIOActivity;
import android.os.Bundle;
import android.widget.FrameLayout;
import android.widget.TextView;

public class MainActivity extends AbstractIOIOActivity {
private TextView _varField;
private TextView _msg;
private FrameLayout _drawingFrame;
private Ball _ball;

/**
* Called when the activity is first created. Here we normally initialize our GUI.
*/
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//        Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
//            @Override
//            public void uncaughtException(Thread thread, Throwable ex) {
//                Log.e("", "", ex);
//            }
//        });

setContentView(R.layout.main);
_varField = (TextView) findViewById(R.id.textViewVarVal);
_msg = (TextView) findViewById(R.id.textViewMsg);

_drawingFrame = (FrameLayout) findViewById(R.id.drawingFrame);
_ball = new Ball(_drawingFrame.getContext(), 15);
_drawingFrame.addView(_ball);
}

/**
* 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 {
private final IOIONunchuck _nunchuck = new IOIONunchuck();
private PwmOutput _led; // The on-board LED
private boolean _ledOn = false;

/**
* Called every time a connection with IOIO has been established.
* Typically used to open pins.
*
* @throws ConnectionLostException When IOIO connection is lost.
*/
@Override
protected void setup() throws ConnectionLostException {
try {
_led = ioio_.openPwmOutput(0, 300);
_led.setDutyCycle(0);

_nunchuck.init(ioio_);
} catch (Exception e) {
msg(e);
}
}

/**
* Called repetitively while the IOIO is connected.
*
* @throws ConnectionLostException When IOIO connection is lost.
*/
@Override
protected void loop() throws ConnectionLostException {
try {
if(_nunchuck.readData()) {
_ball.setPos(mapPos(_nunchuck.getJoy_x_axis()), mapPos(_nunchuck.getJoy_y_axis()));

runOnUiThread(new Runnable() {
@Override
public void run() {
_varField.setText(String.valueOf(_nunchuck.getJoy_x_axis()));
refreshBall();
}
});

_led.setDutyCycle(_ledOn ? 1 : 0);
_ledOn = ! _ledOn;

Thread.sleep(100);
}
} catch (Exception e) {
msg(e);
}
}
}

private static int mapPos(int value) {
return 128 + value;
}

private void msg(Throwable e){
msg("ERR: " + e.getMessage());
}

private void refreshBall() {
runOnUiThread(new Runnable() {
@Override
public void run() {
_drawingFrame.removeView(_ball);
_drawingFrame.addView(_ball);
}
});
}

private void msg(final String msg){
runOnUiThread(new Runnable() {
@Override
public void run() {
_msg.setText("MSG:  " + msg);
}
});
}

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



_________ Ball.java

package com.trandi.wiinunchuck;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.view.View;

public class Ball extends View {
private float x = 0;
private float y = 0;
private final int r;
private final Paint mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);

public Ball(Context context, int r) {
super(context);
mPaint.setColor(0xFFFF0000);
this.r = r;
}

public void setPos(float x, float y) {
this.x = x;
this.y = y;
}

@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
canvas.drawCircle(x, y, r, mPaint);
}
}

And finally, the layout XML, for completeness, even though I doubt is very useful :

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout android:id="@+id/AbsoluteLayout1" xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<ToggleButton android:text="ToggleButton" android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/button"></ToggleButton>
<TextView android:text="Var" android:id="@+id/textViewVar" android:layout_width="wrap_content" android:layout_height="wrap_content"></TextView>
<TextView android:text="Var value" android:id="@+id/textViewVarVal" android:textAppearance="?android:attr/textAppearanceLarge" android:layout_width="wrap_content" android:layout_height="wrap_content"></TextView>
<TextView  android:text="Message" android:id="@+id/textViewMsg"  android:layout_height="wrap_content" android:layout_width="wrap_content"></TextView>
<FrameLayout android:id="@+id/drawingFrame" android:layout_height="match_parent" android:layout_width="match_parent"/>
</LinearLayout>

Android + IOIO controlling a RC servo

It simply adds a RC servo that is controlled by the same seekBar that controls the brightness of the LED.

Here’s a quick and pretty good explanation of how the standard RC protocol (just a specific case of PWM really !) works :
http://www.societyofrobots.com/robotforum/index.php?topic=4299.0
To sum it up, the RC signal is a 50Hz signal, so 20ms period, out of which it is HIGH between 1 and 2ms. So the duty cycle of the signal has to be between 5 and 10%, with the neutral being around 7.5%.

Here’s a video showing the theory working:

And here’s the Android code.

2 things to notice:

1. _servo = ioio_.openPwmOutput(5, 50);  that starts a PWM signal on pin 5, with a 20ms period (corresponding to what the standard RC signal expects)
2. _servo.setDutyCycle(0.05f + _varValue * 0.05f); which basically varies the duty cyle between 5 and 10% (depending on the position of the seekBar) so that the HIGH period of the signal will vary between 1 and 2 milliSeconds (again corresponding to that a RC servo/ESC or anything else, expects)

package org.trandi.helloioio;

import ioio.examples.hello.R;
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;

public class MainActivity extends AbstractIOIOActivity {
private SeekBar _seekBarVar;
private TextView _varField;
private volatile float _varValue;

/**
* 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);
_seekBarVar = (SeekBar) findViewById(R.id.seekBarVar);
_varField = (TextView) findViewById(R.id.textViewVarVal);

_seekBarVar.setMax(100);

_seekBarVar.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) {
_varValue = (float)progress / (float)_seekBarVar.getMax();
_varField.setText(String.valueOf(_varValue));
}
});
}

/**
* 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;
// a attached servo
private PwmOutput _servo;

/**
* 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);
_servo = ioio_.openPwmOutput(5, 50); // 20ms periods
}

/**
* 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 {
_servo.setDutyCycle(0.05f + _varValue * 0.05f);
_led.setDutyCycle(1 - _varValue);
}
}

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

I’m more than open to any interesting suggestion…

Project Box Final

One would actually wonder WHY would I build such a thing, if I don’t have any concrete application for it… the answer is simple : ” the joystick” ! I knew I wanted one, since I saw it the first time a year or so ago… I had been fighting with myself ever since, but finally a couple of weeks ago, I “had” to buy it… and now that I have it, I have to mount it on something…

Project Box 1

Project Box 2

Project Box 3

Project Box 4