‘INTERFACE’ Exhibition @ The Powerhouse Museum

Categories Design, Technology

If you get excited about how design bridges intent to output, you’ll enjoy looking at and thinking about the collection at INTERFACE as much as I did…

BzeCJTSCcAAc-Pn

The Sydney Powerhouse Museum’s INTERFACE exhibition has curated a collection of devices and objects that provide a physical, mental or conceptual bridge between the output of a tool and the human controlling it.

Part of the collection (“The Three Phases of Adoption”) takes variously similar manifestations of a device and allocates them into three categories of user; enthusiast, professional and consumer. The role of design in this process is to reduce technological complexity.

I tried to identify the similarities and omissions (the overall expression) of each manifestation of a similar type of interface. I thought about how this happens in more traditional artforms – for instance two artists painting the same subject may choose to omit and include or augment and diminish differing aspects of the subject in order to convey what they feel is necessary. I found it particularly curious in seeing which elements of interface (patterns) are retained in both the enthusiast and the consumer iterations. In some cases, the interfaces were extremely similar, suggesting other values at play in their fate: The Rio PMP300 (1998) and the Apple iPod (2001) both achieved widely different amounts of commercial success. The iPod is a household name for instance, whereas I had never seen the PMP300 before. What struck me was how similar they were at a glance – which brings into question the surrounding systems and societal attitude towards technologies that allow a consumer electronic product to thrive or die. In terms of the iPod in particular “…the value of the device was cemented by its seamlessness with the iTunes music management software”[1]

Maybe I am projecting here, but non-complexity and minimalism are not as intertwined as designers may like to fetishise. In fact, minimalism can be baffling at it’s most beautiful. But as always, design isn’t solely about beauty, and I was reminded of Raymond Loewy’s “Most advanced yet acceptable” principle.

The exhibition also explores gestural, democratic and a slew of personal computing devices. There’s even an old Apple I Personal Computer in a suitcase housing.

Book Review: Arduino Home Automation Projects

Categories Design, Interaction, Open-source, Programming, Technology

ishot-5

Arduino Home Automation Projects is a practical step-by-step guide to entering into the world of ‘DIY Home Automation’. The benefits of a DIY Arduino based approach to automation that this book puts forth are those of a vastly reduced expense as compared to a commercial fit-out, more control through understanding and an endlesslessly customisable solution.

The book covers real-world examples of use: Motion detection, Controlling lights using a smartphone or tablet, measuring temperature with bluetooth and even explores cloud implementation.

What I find most exciting is the chapter on hacking an existing commercial home automation device. I hope readers find the concept of hijacking existing products with their Arduino’s for their own benefit to be useful in other arenas outside of ‘home automation’ and I can definitely see the skills presented in this book being translated into future projects.

For those strictly interested in ‘home automation’, the book wraps things up with everything you need to build your very own custom solution from scratch – including 3D printed casings and custom PCB’s – which exposes the reader to invaluable skills they can use outside of the subject matter.

ishot-6
The book is well illustrated and documented with photography which is essential for learning. I would recommend this book to students and hobbyists who have experimented with a stand-alone Arduino but have yet to let their Arduino experiment with the world around them.

Synaesynth @ The Bella Union, Melbourne

Categories Design, Interaction, Visuals

Goodtimes Forever Again

I was kindly invited to bring along my interactive colour to sound conversion instrument to “Good Times Forever Again”, a night which originated in Sydney and later made it’s way to (the welcoming open arms of) Melbourne.

The talent there was amazing, each band had a unique and well-explored sound, the entire night was set against a backdrop of wonderful animated illustrations by Meg O’Shea, some nude body painting and a legitimate magician. I’ve never seen someone make objects appear, dissapear and otherwise transmogrify right in plain sight before.

From the event page:

This is the second Goodtimes Forever show in Melbourne after the first big night back in April, making it the third since the event kicked-of started in Sydney.  This night is going to offer you a mix of the (un)usual music, art and goodtimes, but for the first time they’re gonna have a MAGICIAN!

Book Review: Internet of Things with Arduino Yun

Categories Interaction, Open-source, Programming, Technology

Internet of Things with the Arduino Yun

Internet of Things with the Arduino Yun is a well-paced practical introduction to creating and exploring DIY smart devices. Or, as the book phrases it; “projects to help you build a world of smarter things”.

Each example project explores a specific real-world scenario similar to that of existing applications of Internet of Things (IoT) technologies within industry. Each example also exposes the reader to concepts and techniques that should be easily transferrable to many other projects and applications. Covering the subjects of sensing, data collection, automation and long-term presence, the book gives readers a good overview of the broad concerns that need to be considered when designing smart devices.

Power Consumption Data

An example of the kind of data readers might
gather about objects and habits within their home

 

Impressively, the book doesn’t require a great deal of prior knowledge to navigate, though some interest in coding and electronics is of course necessary. Those already familiar with Arduino will benefit from the exploration of the networking aspects of Arduino Yun as they are a bit different to control than what one might be used to with prior versions of the Arduino. The book would make a great companion for those unboxing an Arduino Yun for the first time.

EnviS wins at the 2014 iAwards (Vic)

Categories Design, Technology, UX Design

SAMSUNG

I went to the iAwards night alongside the other talented members of a project I worked on called EnviS. The project won the post-graduate category, which was a great honour for me and I’m really glad to see the hard work put into the project given recognition. I’m excited to see what opportunities await our team in the future. From here, we go on to compete in the National event…

 

AIIA ICT Industry Night

Categories Design, RMIT, Technology

Last night I went to the AIIA Industry Night at RMIT Storey Hall to help present a Computer Science project I was involved with on the Product Development side. Coming from an Industrial Design background I was impressed with how well the school of Computer Science & IT directly engages with industry players, I met a lot of great people and saw a diverse range of interesting and insightful projects. Hopefully in the future I’ll come across some of them in the wild.

AIIA Industry Night AIIA Industry Night AIIA Industry Night AIIA Industry Night AIIA Industry Night AIIA Industry Night

Using Xbee with Arduino Yún

Categories Interaction, Open-source, Programming, Technology

Came across an issue today when upgrading a project I’m currently working on to make use of an Xbee + Arduino Yún stack instead of an Xbee + Arduino Uno stack and found that the solution wasn’t very apparent online. I thought I’d post a short writeup here. Special thanks to Bo for solving this issue.

Firstly, the Yún is amazing in that is has built-in WiFi capabilities, but this also means a few peculiarities with the serial due to the split architecture. If you are trying to use an Xbee with a shield, you will need to make a few modifications to both hardware and code in order to get it working.

Firstly, we cannot use the normal serial communication pins (0,1) and instead need to use alternative pins. I assumed I could use the SoftwareSerial library to allocate another set of pins (for example 10, 11) however for reasons I still don’t fully understand this doesn’t work either.

The solution was suggested by cmaglie in this thread to use AltSoftwareSerial (download the library here). I had not heard of AltSoftwareSerial before, it is an emulated serial comm.

What you need to do is install the above library (read here if you have never done that before) and change your code to include the new serial method. The example code below will recieve packets from another device and print them to serial:

#include <XBee.h>
#include <AltSoftSerial.h>

XBee _xbee = XBee();
AltSoftSerial altSerial;

void setup()
{
  Serial.begin(9600);
  altSerial.begin(9600);
  _xbee.begin(altSerial);
}

void loop()
{
  value="";
  processXBeePackets();  
}

void processXBeePackets()
{
   _xbee.readPacket();
   if (_xbee.getResponse().isAvailable())
   {
      _xbee.getResponse().getZBRxResponse(rx);
      //Serial.println(rx.getDataLength());
      for(int i=0;i<rx.getDataLength();i++){
         value.concat(char(rx.getData(i)));
   }

   Serial.println(value);
   }
}

Then on the hardware side, you need to modify your Xbee shield (or if not using a shield, simply reroute your pin-out). This is as simple as bending out two header pins (we’ve used spacers) so that they don’t actually come into contact with their Arduino counterparts. So, pins 2 and 3 don’t connect to Arduino and we instead use some jumpers to reroute them to 5 and 13 respectively. See the images for reference:

Xbee shield working on Arduino Yun
Rerouting pin 3 > 5 and pin 2 > 13

 

sparkfun xbee shield header pins modified for serial with Yun
The header pins for 2 and 3 need to be bent so that they don’t interface with the arduino.

You should now be able to pass your Xbee communication data on to your Arduino Yún and then pass it on to a server or computer via WiFi.

UX Design: Academic papers reading list

Categories Design, UX Design
I pulled this list of papers (and books) whilst reading “Universal Principle of Design” by William Lidwell. The following seemed interesting from a design perspective, and from those that I’ve found access to and read they’ve yet to be boring:
  • “Categorization  of Action Slips” by Donald A. Norman
  • “All That Glitters: A Review of Psychological Research on the Aesthetics of the Golden Section” by Christopher D. Green, Perception, 1995
  • “Did Mozart Use the Golden Section?” by Mike May, American Scientist,March-April 1996
  • “Application of Fitts’ Law to Foot-Pedal Design” by Colin G. Drury, Human Factors, 1975
  • “The Information Capacity of the Human Motor System in Controlling Amplitude of Movement” by Paul M. Fitts, Journal of Experimental Psychology, 1954,
  • “The Visible Problems of the Invisible Computer: A Skeptical Look at Information Appliances” by Andrew Odlyzko, First Monday, 1999
  • “The Framing of Decisions and the Psychology of Choice” by Amos Tversky and Daniel Kahneman, Science, 1981
  • “On the Rate of Gain of Information” by W. E. Hick, Quarterly Journal of Experimental Psychology, 1952
  • “The Architecture of Complexity,” Proceedings of the American Philosophical Society, 1962,
  • “Icons at the Interface: Their Usefulness” by Yvonne Rogers, Interacting With Computers
  • “International Investment and International Trade in the Product Cycle” by Raymond Vernon,Quarterly Journal of Economics,1966,
  • “Surrogates and Mappings: Two Kinds of Conceptual Models for Interactive Devices” by Richard M. Young
  • “Some Observations on Mental Models” by Donald Norman
  • “A Message from Earth” by Carl Sagan, Linda Salzman Sagan, and Frank Drake, Science, Feb. 25, 1972, vol. 175(4024), p. 881–884
  • “Training Wheels in a User Interface” by John M. Carroll and Caroline Carrithers,Communications of the ACM,1984,
  • “The Xerox ‘Star’: A Retrospective” by Jeff Johnson and Teresa L. Roberts, William Verplank, David C. Smith, Charles Irby, Marian Beard, Kevin Mackey, inHuman Computer Interaction: Toward the Year 2000

I will probably continue to add to this list over time.

academic papers

Design Play Cards at National Gallery of Victoria

Categories Design, Visuals

The Design Play Cards are going to be exhibited in the NGV as part of the #melbournenow exhibition, which runs from November 22, 2013 up until March 23, 2014.

Melbourne Now celebrates the latest art, architecture, design, performance and cultural practice to reflect the complex cultural landscape of creative Melbourne. This ambitious and far-reaching exhibition across NGV Australia and NGV International will show how visual artists and creative practitioners have profoundly contributed to creating a place with a unique and dynamic cultural identity.

read more

More than 300 hundred talented artists, architects, designers and others are going to be exhibited. It’s free entry so come along and have at look at what Melbourne has to offer.

Melbourne Now | 22 Nov - 23 Mar | FREE ENTRY

How to send multiple variables from Processing to Arduino

Categories Interaction, Programming

I wanted to be able to send a set of 4 integers to an Arduino from a Processing application that I am working on, I also wanted to be able to prefix the set with a tag, so that I could deal with different sets of integers in specific ways, for specific purposes.

For instance, I have an LCD screen and some LED’s connected to my Arduino, or maybe I have a servo motor and a speaker that I want to control based on events happening in software running via Processing.

I modified* the code below from the code shown here (Arduino Cookbook @ inkling.com)

*I simply expanded the amount of variables being sent per packet.

Processing Code:

// Processing Sketch

/* SendingBinaryToArduino
 * Language: Processing
 */
import processing.serial.*;

Serial myPort;  // Create object from Serial class
public static final char HEADER    = 'H';
public static final char A_TAG = 'M';
public static final char B_TAG = 'X';

void setup()
{
  size(512, 512);
  String portName = Serial.list()[1];
  myPort = new Serial(this, portName, 9600);
}

void draw(){
}

void serialEvent(Serial p) {
  // handle incoming serial data
  String inString = myPort.readStringUntil('\n');
  if(inString != null) {     
    print( inString );   // echo text string from Arduino
  }
}

void mousePressed() {
  sendMessage(A_TAG, 8,5,20,33);
}

void sendMessage(char tag, int a, int b, int c, int d){
  // send the given index and value to the serial port
  myPort.write(HEADER);
  myPort.write(tag);
  myPort.write((char)(a / 256)); // msb
  myPort.write(a & 0xff);  //lsb
  myPort.write((char)(b / 256)); // msb
  myPort.write(b & 0xff);  //lsb
  myPort.write((char)(c / 256)); // msb
  myPort.write(c & 0xff);  //lsb
  myPort.write((char)(d / 256)); // msb
  myPort.write(d & 0xff);  //lsb
}

You can see in the void sendMessage function that each integer is being split into two bytes, but both the header and tag are sent as a single byte – this means we are sending 10 bytes all up (we will need to reference this in the Arduino code in TOTAL_BYTES).

Arduino Code:

// BinaryDataFromProcessing
// These defines must mirror the sending program:
const char HEADER       = 'H';
const char A_TAG    = 'M';
const char B_TAG    = 'X';
const int  TOTAL_BYTES  = 10  ; // the total bytes in a message

void setup()
{
  Serial.begin(9600);
}

void loop(){
  if ( Serial.available() >= TOTAL_BYTES)
  {
     if( Serial.read() == HEADER)
    {
      char tag = Serial.read();
      if(tag == A_TAG)
      {
        //Collect integers
        int a = Serial.read() * 256; 
        a = a + Serial.read();
        int b = Serial.read() * 256;
        b = b + Serial.read();
        int c = Serial.read() * 256;
        c = c + Serial.read();
        int d = Serial.read() * 256;
        d = d + Serial.read();
        Serial.print("Received integers | a:");
        Serial.print(a);
        Serial.print(", b:");
        Serial.println(b);
        Serial.print(", c:");
        Serial.println(c);
        Serial.print(", d:");
        Serial.println(d);
      }
      else {
        Serial.print("got message with unknown tag ");
        Serial.write(tag);
      }
    }
  }
}

You can see under Serial.available() after the comment “//Collect integers” that each byte is being stored in a variable (multiplied by 256 to reverse the division on the Processing side) and then the second byte is added to that (thus reversing the rejoining the split that took place on the Processing side) – in this way we are reassembling the data that we sent into a useable format to be used.

From here you can do whatever you like with the data, use it for conditionals or set it to analog outputs. The applications are nearly endless.