SPOKA Night Light controlled from and Android Phone

You people must have been wondering “what the heck was going on” and why haven’t I posted anything for the last 3 months or so… keep reading and you’ll find out more !

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...

Advertisement