Archive for December, 2010

Date: December 15th, 2010
Cate: Doing

Hang On: An Arduino Mini-Project

Hang On is a coat rack which reads the weather from the internet and displays it as a simple symbol for the user to see, to aid them when choosing a coat.

Processing pulls the weather data from an XML feed via the Google Weather API and scans the forecast for key terms. These key terms allow the program to pick the nearest weather condition from four I have specified: sunny, cloudy, rainy or snowy. Firmata is installed on the Arduino board, which controls the physical output – an LED light behind a tiny screen in the coat rack.

Click here to download the PDF of my technical implementation and user scenarios.

I decided to create this project because I have been working for some time on pulling data from my Twitter timeline. This has so far proved complicated and I have not yet been successful – so I thought this would be a good opportunity to try something similar but in a more simple state. I like the simplicity of simply displaying the weather. Initially I was going to just make a device – similar to Fido, a project Adrian kindly pointed me towards – but the designer in me wanted to make something more “useful”. I consider simplicity and thoughtfulness to be the two main characteristics in all my design work and I feel Hang On captures both of these.

Here is the Processing code (StandardFirmata is running on Arduino):

// Coat Rack
// Joanna Montgomery Culture Lab 2010
//Weather from the Yahoo Weather website
import processing.xml.*;
import processing.serial.*;
import cc.arduino.*;
Arduino arduino;
//input pins
int sunnyPin = 13;  //pin for sunny light
int cloudyPin = 12;  //pin for cloudy light
int rainyPin = 11;  //pin for rainy light
int snowyPin = 10;  //pin for snowy light
String condition;  //weather condition from xml feed
XMLElement xml;
void setup() {
println(Arduino.list());
arduino = new Arduino(this, Arduino.list()[0], 115200);  //arduino set up
arduino.pinMode(sunnyPin, Arduino.OUTPUT);  //set pin as output
arduino.pinMode(cloudyPin, Arduino.OUTPUT); //set pin as output
arduino.pinMode(rainyPin, Arduino.OUTPUT);  //set pin as output
arduino.pinMode(snowyPin, Arduino.OUTPUT);  //set pin as output
size(200, 200);
//The following section of code was by Tom, without whom my project would have died
//collect data from xml
//declare a new master xml element – this is the parent node which contains everything else
//the xml is invisible until you right click on the page and choose show source
xml = new XMLElement(this, “http://www.google.com/ig/api?weather=NE17RU”);
//get the next level down which is called “weather”
XMLElement weather = xml.getChild(“weather”);
//get the level below weather called current_conditions
XMLElement cond=weather.getChild(“current_conditions”);
//its always nice to count how many children each node has to give yo uan idea of wher you are at
println(cond.getChildCount());
//current_conditions has a child called condition
XMLElement current =cond.getChild(“condition”);
//and inside that child is an attribute called data which has the description
condition=current.getStringAttribute(“data”);
}
//End of code from Tom
//These are the basic weather conditions I’m working with, as well as a test which runs through all 4
//condition = “Snow”;
//condition = “Mostly Cloudy”;
//condition = “Light Rain”;
//condition = “Fair”;
//condition = “Test”;
void draw()
{ //if condition is sunny
if (condition.equals(“Fair”) ||
condition.equals(“Clear”) ||
condition.equals(“Fair with Haze”) ||
condition.equals(“Clear with Haze”) ||
condition.equals(“Fair and Breezy”) ||
condition.equals(“Clear and Breezy”) ||
condition.equals(“A Few Clouds”) ||
condition.equals(“A Few Clouds with Haze”) ||
condition.equals(“A Few Clouds and Breezy”) ||
condition.equals(“Windy”) ||
condition.equals(“Breezy”) ||
condition.equals(“Fair and Windy”) ||
condition.equals(“A Few Clouds and Windy”)
) {
//light up sunny
arduino.digitalWrite(sunnyPin, Arduino.HIGH);   // turns the sunny light on
//delay(1000);                                    // waits for a second
//arduino.digitalWrite(sunnyPin, Arduino.LOW);    // turns the sunny light off
//delay(1000);                                    // waits for a second
}
//if condition is cloudy
else if (condition.equals(“Mostly Cloudy”) ||
condition.equals(“Mostly Cloudy with Haze”) ||
condition.equals(“Mostly Cloudy and Breezy”) ||
condition.equals(“Partly Cloudy”) ||
condition.equals(“Partly Cloudy with Haze”) ||
condition.equals(“Partly Cloudy and Breezy”) ||
condition.equals(“Overcast”) ||
condition.equals(“Overcast with Haze”) ||
condition.equals(“Overcast and Breezy”) ||
condition.equals(“Fog/Mist”) ||
condition.equals(“Fog”) ||
condition.equals(“Freezing Fog”) ||
condition.equals(“Shallow Fog”) ||
condition.equals(“Partial Fog”) ||
condition.equals(“Patches of Fog”) ||
condition.equals(“Fog in Vicinity”) ||
condition.equals(“Freezing Fog in Vicinity”) ||
condition.equals(“Shallow Fog in Vicinity”) ||
condition.equals(“Partial Fog in Vicinity”) ||
condition.equals(“Patches of Fog in Vicinity”) ||
condition.equals(“Showers in Vicinity Fog”) ||
condition.equals(“Light Freezing Fog”) ||
condition.equals(“Heavy Freezing Fog “) ||
condition.equals(“Smoke”) ||
condition.equals(“Partly Cloudy and Windy”) ||
condition.equals(“Mostly Cloudy and Windy”) ||
condition.equals(“Overcast and Windy”) ||
condition.equals(“Funnel Cloud”) ||
condition.equals(“Funnel Cloud in Vicinity”) ||
condition.equals(“Tornado/Water Spout “) ||
condition.equals(“Dust”) ||
condition.equals(“Low Drifting Dust”) ||
condition.equals(“Blowing Dust”) ||
condition.equals(“Sand”) ||
condition.equals(“Blowing Sand”) ||
condition.equals(“Low Drifting Sand”) ||
condition.equals(“Dust/Sand Whirls”) ||
condition.equals(“Dust/Sand Whirls in Vicinity”) ||
condition.equals(“Dust Storm”) ||
condition.equals(“Heavy Dust Storm”) ||
condition.equals(“Dust Storm in Vicinity”) ||
condition.equals(“Sand Storm”) ||
condition.equals(“Heavy Sand Storm”) ||
condition.equals(“Sand Storm in Vicinity  ”) ||
condition.equals(“Haze”)
) {
//light up cloudy
arduino.digitalWrite(cloudyPin, Arduino.HIGH);   // turns the cloudy light on
//delay(1000);                                      // waits for a second
//arduino.digitalWrite(cloudyPin, Arduino.LOW);    // turns the cloudy light off
//delay(1000);                                      // waits for a second
}
//if condition is rainy
else if (condition.equals(“Freezing Rain”) ||
condition.equals(“Freezing Drizzle”) ||
condition.equals(“Light Freezing Rain”) ||
condition.equals(“Light Freezing Drizzle”) ||
condition.equals(“Heavy Freezing Rain”) ||
condition.equals(“Heavy Freezing Drizzle”) ||
condition.equals(“Freezing Rain in Vicinity”) ||
condition.equals(“Freezing Drizzle in Vicinity “) ||
condition.equals(“Rain Showers”) ||
condition.equals(“Light Rain Showers”) ||
condition.equals(“Light Rain and Breezy”) ||
condition.equals(“Heavy Rain Showers”) ||
condition.equals(“Rain Showers in Vicinity”) ||
condition.equals(“Light Showers Rain”) ||
condition.equals(“Heavy Showers Rain”) ||
condition.equals(“Showers Rain”) ||
condition.equals(“Showers Rain in Vicinity”) ||
condition.equals(“Rain Showers Fog/Mist”) ||
condition.equals(“Light Rain Showers Fog/Mist”) ||
condition.equals(“Heavy Rain Showers Fog/Mist”) ||
condition.equals(“Rain Showers in Vicinity Fog/Mist”) ||
condition.equals(“Light Showers Rain Fog/Mist”) ||
condition.equals(“Heavy Showers Rain Fog/Mist”) ||
condition.equals(“Showers Rain Fog/Mist”) ||
condition.equals(“Showers Rain in Vicinity Fog/Mist”) ||
condition.equals(“Thunderstorm”) ||
condition.equals(“Thunderstorm Rain”) ||
condition.equals(“Light Thunderstorm Rain”) ||
condition.equals(“Heavy Thunderstorm Rain”) ||
condition.equals(“Thunderstorm Rain Fog/Mist”) ||
condition.equals(“Light Thunderstorm Rain Fog/Mist”) ||
condition.equals(“Heavy Thunderstorm Rain Fog and Windy”) ||
condition.equals(“Heavy Thunderstorm Rain Fog/Mist”) ||
condition.equals(“Thunderstorm Showers in Vicinity”) ||
condition.equals(“Light Thunderstorm Rain Haze”) ||
condition.equals(“Heavy Thunderstorm Rain Haze”) ||
condition.equals(“Thunderstorm Fog”) ||
condition.equals(“Light Thunderstorm Rain Fog”) ||
condition.equals(“Heavy Thunderstorm Rain Fog”) ||
condition.equals(“Thunderstorm Light Rain”) ||
condition.equals(“Thunderstorm Heavy Rain”) ||
condition.equals(“Thunderstorm Rain Fog/Mist”) ||
condition.equals(“Thunderstorm Light Rain Fog/Mist”) ||
condition.equals(“Thunderstorm Heavy Rain Fog/Mist”) ||
condition.equals(“Thunderstorm in Vicinity Fog/Mist”) ||
condition.equals(“Thunderstorm Showers in Vicinity”) ||
condition.equals(“Thunderstorm in Vicinity Haze”) ||
condition.equals(“Thunderstorm Haze in Vicinity”) ||
condition.equals(“Thunderstorm Light Rain Haze”) ||
condition.equals(“Thunderstorm Heavy Rain Haze”) ||
condition.equals(“Thunderstorm Fog”) ||
condition.equals(“Thunderstorm Light Rain Fog”) ||
condition.equals(“Thunderstorm Heavy Rain Fog”) ||
condition.equals(“Thunderstorm Hail”) ||
condition.equals(“Light Thunderstorm Rain Hail”) ||
condition.equals(“Heavy Thunderstorm Rain Hail”) ||
condition.equals(“Thunderstorm Rain Hail Fog/Mist”) ||
condition.equals(“Light Thunderstorm Rain Hail Fog/Mist”) ||
condition.equals(“Heavy Thunderstorm Rain Hail Fog/Hail”) ||
condition.equals(“Thunderstorm Showers in Vicinity Hail”) ||
condition.equals(“Light Thunderstorm Rain Hail Haze”) ||
condition.equals(“Heavy Thunderstorm Rain Hail Haze”) ||
condition.equals(“Thunderstorm Hail Fog”) ||
condition.equals(“Light Thunderstorm Rain Hail Fog”) ||
condition.equals(“Heavy Thunderstorm Rain Hail Fog”) ||
condition.equals(“Thunderstorm Light Rain Hail”) ||
condition.equals(“Thunderstorm Heavy Rain Hail”) ||
condition.equals(“Thunderstorm Rain Hail Fog/Mist”) ||
condition.equals(“Thunderstorm Light Rain Hail Fog/Mist”) ||
condition.equals(“Thunderstorm Heavy Rain Hail Fog/Mist”) ||
condition.equals(“Thunderstorm in Vicinity Hail”) ||
condition.equals(“Thunderstorm in Vicinity Hail Haze”) ||
condition.equals(“Thunderstorm Haze in Vicinity Hail”) ||
condition.equals(“Thunderstorm Light Rain Hail Haze”) ||
condition.equals(“Thunderstorm Heavy Rain Hail Haze”) ||
condition.equals(“Thunderstorm Hail Fog”) ||
condition.equals(“Thunderstorm Light Rain Hail Fog”) ||
condition.equals(“Thunderstorm Heavy Rain Hail Fog”) ||
condition.equals(“Thunderstorm Small Hail/Snow Pellets”) ||
condition.equals(“Thunderstorm Rain Small Hail/Snow Pellets”) ||
condition.equals(“Light Thunderstorm Rain Small Hail/Snow Pellets”) ||
condition.equals(“Heavy Thunderstorm Rain Small Hail/Snow Pellets”) ||
condition.equals(“Showers in Vicinity”) ||
condition.equals(“Showers in Vicinity Fog/Mist”) ||
condition.equals(“Showers in Vicinity Fog”) ||
condition.equals(“Showers in Vicinity Haze “) ||
condition.equals(“Freezing Rain Rain”) ||
condition.equals(“Light Freezing Rain Rain”) ||
condition.equals(“Heavy Freezing Rain Rain”) ||
condition.equals(“Rain Freezing Rain”) ||
condition.equals(“Light Rain Freezing Rain”) ||
condition.equals(“Heavy Rain Freezing Rain”) ||
condition.equals(“Freezing Drizzle Rain”) ||
condition.equals(“Light Freezing Drizzle Rain”) ||
condition.equals(“Heavy Freezing Drizzle Rain”) ||
condition.equals(“Rain Freezing Drizzle”) ||
condition.equals(“Light Rain Freezing Drizzle”) ||
condition.equals(“Heavy Rain Freezing Drizzle “) ||
condition.equals(“Thunderstorm in Vicinity”) ||
condition.equals(“Thunderstorm in Vicinity Fog”) ||
condition.equals(“Thunderstorm in Vicinity Haze “) ||
condition.equals(“Light Rain”) ||
condition.equals(“Drizzle”) ||
condition.equals(“Light Drizzle”) ||
condition.equals(“Heavy Drizzle”) ||
condition.equals(“Light Rain Fog/Mist”) ||
condition.equals(“Drizzle Fog/Mist”) ||
condition.equals(“Light Drizzle Fog/Mist”) ||
condition.equals(“Heavy Drizzle Fog/Mist”) ||
condition.equals(“Light Rain Fog”) ||
condition.equals(“Drizzle Fog”) ||
condition.equals(“Light Drizzle Fog”) ||
condition.equals(“Heavy Drizzle Fog “) ||
condition.equals(“Rain”) ||
condition.equals(“Heavy Rain”) ||
condition.equals(“Rain Fog/Mist”) ||
condition.equals(“Heavy Rain Fog/Mist”) ||
condition.equals(“Rain Fog”) ||
condition.equals(“Heavy Rain Fog”)
) {
//light up rainy
arduino.digitalWrite(rainyPin, Arduino.HIGH);   // turns the rainy light on
//delay(1000);                                    // waits for a second
//arduino.digitalWrite(rainyPin, Arduino.LOW);    // turns the rainy light off
//delay(1000);                                    // waits for a second
}
//if condition is snowy
else if (condition.equals(“Ice Pellets”) ||
condition.equals(“Light Ice Pellets”) ||
condition.equals(“Heavy Ice Pellets”) ||
condition.equals(“Ice Pellets in Vicinity”) ||
condition.equals(“Showers Ice Pellets”) ||
condition.equals(“Thunderstorm Ice Pellets”) ||
condition.equals(“Ice Crystals”) ||
condition.equals(“Hail”) ||
condition.equals(“Small Hail/Snow Pellets”) ||
condition.equals(“Light Small Hail/Snow Pellets”) ||
condition.equals(“Heavy small Hail/Snow Pellets”) ||
condition.equals(“Showers Hail”) ||
condition.equals(“Hail Showers”) ||
condition.equals(“Freezing Rain Snow”) ||
condition.equals(“Light Freezing Rain Snow”) ||
condition.equals(“Heavy Freezing Rain Snow”) ||
condition.equals(“Freezing Drizzle Snow”) ||
condition.equals(“Light Freezing Drizzle Snow”) ||
condition.equals(“Heavy Freezing Drizzle Snow”) ||
condition.equals(“Snow Freezing Rain”) ||
condition.equals(“Light Snow Freezing Rain”) ||
condition.equals(“Heavy Snow Freezing Rain”) ||
condition.equals(“Snow Freezing Drizzle”) ||
condition.equals(“Light Snow Freezing Drizzle”) ||
condition.equals(“Heavy Snow Freezing Drizzle”) ||
condition.equals(” Rain Ice Pellets”) ||
condition.equals(“Light Rain Ice Pellets”) ||
condition.equals(“Heavy Rain Ice Pellets”) ||
condition.equals(“Drizzle Ice Pellets”) ||
condition.equals(“Light Drizzle Ice Pellets”) ||
condition.equals(“Heavy Drizzle Ice Pellets”) ||
condition.equals(“Ice Pellets Rain”) ||
condition.equals(“Light Ice Pellets Rain”) ||
condition.equals(“Heavy Ice Pellets Rain”) ||
condition.equals(“Ice Pellets Drizzle”) ||
condition.equals(“Light Ice Pellets Drizzle”) ||
condition.equals(“Heavy Ice Pellets Drizzle “) ||
condition.equals(“Rain Snow”) ||
condition.equals(“Light Rain Snow”) ||
condition.equals(“Heavy Rain Snow”) ||
condition.equals(“Snow Rain”) ||
condition.equals(“Light Snow Rain”) ||
condition.equals(“Heavy Snow Rain”) ||
condition.equals(“Drizzle Snow”) ||
condition.equals(“Light Drizzle Snow”) ||
condition.equals(“Heavy Drizzle Snow”) ||
condition.equals(“Snow Drizzle”) ||
condition.equals(“Light Snow Drizzle”) ||
condition.equals(“Heavy Drizzle Snow”) ||
condition.equals(“Snow”) ||
condition.equals(“Light Snow”) ||
condition.equals(“Heavy Snow”) ||
condition.equals(“Snow Showers”) ||
condition.equals(“Light Snow Showers”) ||
condition.equals(“Heavy Snow Showers”) ||
condition.equals(“Showers Snow”) ||
condition.equals(“Light Showers Snow”) ||
condition.equals(“Heavy Showers Snow”) ||
condition.equals(“Snow Fog/Mist”) ||
condition.equals(“Light Snow Fog/Mist”) ||
condition.equals(“Heavy Snow Fog/Mist”) ||
condition.equals(“Snow Showers Fog/Mist”) ||
condition.equals(“Light Snow Showers Fog/Mist”) ||
condition.equals(“Heavy Snow Showers Fog/Mist”) ||
condition.equals(“Showers Snow Fog/Mist”) ||
condition.equals(“Light Showers Snow Fog/Mist”) ||
condition.equals(“Heavy Showers Snow Fog/Mist”) ||
condition.equals(“Snow Fog”) ||
condition.equals(“Light Snow Fog”) ||
condition.equals(“Heavy Snow Fog”) ||
condition.equals(“Snow Showers Fog”) ||
condition.equals(“Light Snow Showers Fog”) ||
condition.equals(“Heavy Snow Showers Fog”) ||
condition.equals(“Showers Snow Fog”) ||
condition.equals(“Light Showers Snow Fog”) ||
condition.equals(“Heavy Showers Snow Fog”) ||
condition.equals(“Showers in Vicinity Snow”) ||
condition.equals(“Snow Showers in Vicinity”) ||
condition.equals(“Snow Showers in Vicinity Fog/Mist”) ||
condition.equals(“Snow Showers in Vicinity Fog”) ||
condition.equals(“Low Drifting Snow”) ||
condition.equals(“Blowing Snow”) ||
condition.equals(“Snow Low Drifting Snow”) ||
condition.equals(“Snow Blowing Snow”) ||
condition.equals(“Light Snow Low Drifting Snow”) ||
condition.equals(“Light Snow Blowing Snow”) ||
condition.equals(“Light Snow Blowing Snow Fog/Mist”) ||
condition.equals(“Heavy Snow Low Drifting Snow”) ||
condition.equals(“Heavy Snow Blowing Snow”) ||
condition.equals(“Thunderstorm Snow”) ||
condition.equals(“Light Thunderstorm Snow”) ||
condition.equals(“Heavy Thunderstorm Snow”) ||
condition.equals(“Snow Grains”) ||
condition.equals(“Light Snow Grains”) ||
condition.equals(“Heavy Snow Grains”) ||
condition.equals(“Heavy Blowing Snow”) ||
condition.equals(“Blowing Snow in Vicinity”)
) {
//light up snowy
arduino.digitalWrite(snowyPin, Arduino.HIGH);   // turns the snowy light on
//delay(1000);                                    // waits for a second
//arduino.digitalWrite(snowyPin, Arduino.LOW);    // turns the snowy light off
//delay(1000);                                    // waits for a second
}
else if (condition.equals(“Test”)) {
//TEST condition runs through each condition, blinking 3 times for each
//light up sunny
arduino.digitalWrite(sunnyPin, Arduino.HIGH);   // turns sunny light on
delay(1000);                    // waits for a second
arduino.digitalWrite(sunnyPin, Arduino.LOW);    // turns sunny light off
delay(1000);                    // waits for a second
arduino.digitalWrite(sunnyPin, Arduino.HIGH);   // turns sunny light on
delay(1000);                    // waits for a second
arduino.digitalWrite(sunnyPin, Arduino.LOW);    // turns sunny light off
delay(1000);                    // waits for a second
arduino.digitalWrite(sunnyPin, Arduino.HIGH);   // turns sunny light on
delay(1000);                    // waits for a second
arduino.digitalWrite(sunnyPin, Arduino.LOW);    // turns sunny light off
delay(1000);                    // waits for a second
//light up rainy
arduino.digitalWrite(rainyPin, Arduino.HIGH);   // turns the rainy light on
delay(1000);                    // waits for a second
arduino.digitalWrite(rainyPin, Arduino.LOW);    // turns the rainy light off
delay(1000);                    // waits for a second
arduino.digitalWrite(rainyPin, Arduino.HIGH);   // turns the rainy light on
delay(1000);                    // waits for a second
arduino.digitalWrite(rainyPin, Arduino.LOW);    // turns the rainy light off
delay(1000);                    // waits for a second
arduino.digitalWrite(rainyPin, Arduino.HIGH);   // turns the rainy light on
delay(1000);                    // waits for a second
arduino.digitalWrite(rainyPin, Arduino.LOW);    // turns the rainy light off
delay(1000);                    // waits for a second
//light up cloudy
arduino.digitalWrite(cloudyPin, Arduino.HIGH);   // turns the cloudy light on
delay(1000);                    // waits for a second
arduino.digitalWrite(cloudyPin, Arduino.LOW);    // turns the cloudy light off
delay(1000);                    // waits for a second
arduino.digitalWrite(cloudyPin, Arduino.HIGH);   // turns the cloudy light on
delay(1000);                    // waits for a second
arduino.digitalWrite(cloudyPin, Arduino.LOW);    // turns the cloudy light off
delay(1000);                    // waits for a second
arduino.digitalWrite(cloudyPin, Arduino.HIGH);   // turns the cloudy light on
delay(1000);                    // waits for a second
arduino.digitalWrite(cloudyPin, Arduino.LOW);    // turns the cloudy light off
delay(1000);                    // waits for a second
//light up snowy
arduino.digitalWrite(snowyPin, Arduino.HIGH);   // turns the snowy light on
delay(1000);                    // waits for a second
arduino.digitalWrite(snowyPin, Arduino.LOW);    // turns the snowy light off
delay(1000);                    // waits for a second
arduino.digitalWrite(snowyPin, Arduino.HIGH);   // turns the snowy light on
delay(1000);                    // waits for a second
arduino.digitalWrite(snowyPin, Arduino.LOW);    // turns the snowy light off
delay(1000);                    // waits for a second
arduino.digitalWrite(snowyPin, Arduino.HIGH);   // turns the snowy light on
delay(1000);                    // waits for a second
arduino.digitalWrite(snowyPin, Arduino.LOW);    // turns the snowy light off
delay(1000);                    // waits for a second
}
}
//gone slightly insane commenting all this code

Date: December 12th, 2010
Cate: Doing

Weather Symbols

Had a little nosy around online today for some nice weather symbols for my project. Couldn’t find any so cracked out the graphics tablet, opened Illustrator and made my own :-)

Everything I was finding online was really “fussy” or looked very primary school, with yellow suns and grey clouds. I wanted something much more simplistic to fit in with my design, so made them as basic as I could whilst ensuring they still retained their identity as weather symbols.

Date: December 11th, 2010
Cate: Doing

Getting My Build On

I’ve spent my Saturday soldering (I know, I know – you wish you were as cool as me) and have finished building all the electrical components of my Arduino project. Check out my tinsy-winsy resistors – aren’t they adorable?

On the topic of soldering, my boyfriend randomly bought me this magnified “holder for while you solder” thing one day and it is THE BEST THING THAT HAS EVER HAPPENED TO ME. Seriously, I don’t know what I did before this came into my life (actually I do: I short-circuited a lot of things, soldered my fingers a lot and just generally took twice as long to do everything).

Now all I need to do is put it all together. The physical build is getting a bit “woody” so I’m going to leave that for tomorrow – I’m secretly dreading going out to the shed in search of the drill. I’m also not looking forward to finishing this project as it means I’m inevitably going to have zero excuse not to start my Christmas shopping.

Date: December 10th, 2010
Cate: Doing, Thoughts & Reflections

December Doings

My essay outline is done and dusted. In the end I decided that all the philosophy stuff didn’t really engage my brain in a positive way (mostly just confused me!) and I wasn’t really passionate about relating it to my work so I steered away from it in my plan. I’ve decided to write about what exactly interaction design is. I’ve been questioning this notion a lot since Brigitta’s second lecture, when she proffered that for technology to be truly interactive, it needs to process an input and generate a completely unique output. I wasn’t sure if I agreed at first – does this mean that typically “interactive” technologies such as Xboxs, mobile phones etc, are not interactive? Surely they are – but are users starting to expect technology to engage with us on a deeper level? Should interaction design be about providing a completely unique experience to each individual? Over the last few weeks I’ve been reading a lot about it and now I’m actually quite keen to write about it. I’m looking forward to exploring it in more detail – getting my teeth into both arguments and establishing exactly how I feel about it all and how this is reflected in my work.

With the essay outline submitted and out of my mind for the next few days, I can concentrate all of my efforts on my little Arduino project. Here is a sneak preview of it in its crudest, most basic form.

I’ve been using Processing to pull XML data from the BBC Weather website’s RSS feed. It scans the weather forecast for key terms and weather conditions and then passes it to Arduino, which outputs it visually. I’m making an object which will give you an indication of the weather outside. Naturally, being a designer and being obsessed with “usefulness”, I’m going to output it in a vaguely useful/practical way :-)

Date: December 5th, 2010
Cate: Uncategorized

Relay: Take Two

Excuse the horrid webcam photo, it’s 10pm on a Sunday night and I am feeling faaaar too lazy to walk all the way upstairs for my camera. I’ve spent the weekend thinking a bit more about the “relay” theme and am ashamed to say it’s got me fairly stumped. Relay ultimately means to pass something on, so I could pretty much do anything and argue that something, somewhere – even a piece of data – is being passed on. It feels like such a cop out and not even remotely creative.

So I decided just to be honest with myself and what the word means to me. My dad is quite a big The Who fan so I’ve always known the song Relay. Since I was a kid, whenever the weather forecast looks bleak, or clouds are gathering in the sky, my mum will always announce that “a storm is brewing” (which my gran also used to say :-) and my dad always sings the line “Relayyyyyyyy, things are brewing”. So when it comes down to it, the word “relay” makes me think of bad weather!

I’m not really sure if this is a strong enough connection for the brief but I quite like it. I like that it’s different and I like that it’s personal to me. I think I’m going to make something that is controlled by the weather. I’ve been playing a little bit lately with pulling RSS feeds from Twitter (I’m eventually going to make a Twitter orb that will tell me the overall mood of my feed) so I have a pretty solid piece of code I’ve been working on. I think it might be nice to try pulling weather feeds from somewhere, maybe the BBC website, and outputting them in some way – hopefully something useful.

Date: December 3rd, 2010
Cate: Doing

Relay

— noun
1. a person or team of people relieving others, as on a shift
2. a fresh team of horses, dogs, etc, posted at intervals along a route to relieve others
3. the act of relaying or process of being relayed
4. a. short for relay race
b. one of the sections of a relay race
5. an automatic device that controls the setting of a valve, switch, etc, by means of an electric motor, solenoid, or pneumatic mechanism
6. electronics an electrical device in which a small change in current or voltage controls the switching on or off of circuits or other devices
7. radio
a. a combination of a receiver and transmitter designed to receive radio signals and retransmit them, in order to extend their range
b. ( as modifier ): a relay station

— verb
8. to carry or spread (something, such as news or information) by relays
9. to supply or replace with relays
10. to retransmit (a signal) by means of a relay
11. to broadcast by sending out signals through a transmitting station: this concert is being relayed from the Albert Hall

Starting to properly think about my little project for the Doing exhibition. “Relay” is quite a good theme – really broad and open to almost any interpretation. It did initially make me think of the The Who song, before I even scrolled down to the bottom of the post on the DM blog. On a more practical level, it makes me think of passing something on, or passing something back. This is still a bit broad though, as any technology arguably passes something on in one form or another, so I’m going to spend the weekend thinking a little bit more about how I want to narrow it down, then get cracking on the making of it, so if I have any problems I can bring them up on Wednesday.


Date: December 3rd, 2010
Cate: Thinking, Thoughts & Reflections

Philosophy of Technology

“Apply one of the concepts of the Philosophy of Technology 1 & 2 sessions. Reflect on your practice or other scholarly/artistic/design work.”

Philosophy. Usually the word alone, stirring up images of Socrates and old men in Greece, sends me to sleep. However, I’ve never thought about it being applied to technology before. Philosophy has always struck me as something old fashioned, unproven, and lacking any rich qualities allowing it to underpin the foundations of any solid ideas. Have I been too quick to rule out philosophy and the implications it might have on my practice?

“The world of tools is an invisible realm from which the visible structure of the world emerges” (Heidegger, 1967)

Heidegger’s Tool is quite an interesting concept. I like the notion that people use “tools” – whether they are literal or metaphorical, to interact with the world. And do they matter? Does it matter what the “tool” is, and does the user pay any attention to it, if it’s getting the job done and the outcome is the desired result? Or is the tool just as important, is the tool part of the journey, which ultimately both leads to and defines the outcome? This raises a lot of questions for me around aesthetics and usability.

If the technology disappears in the user’s hand as they focus on the immediate performance of the tool – I’ll stick with the hammer example – does the way it looks, the material it is made of, its colour, etc, even matter? I’ve always been a firm believer that the tool is very important. I think any object a person uses is important, and its design/behaviour/aesthetics will ultimately impact on the experience of using it, as well as its performance. I do however like how it talks about the tool being “fused with the body”, as in my work I always aim to make the interaction work with the user’s body as I feel it creates a more fluid interaction, and thus a richer experience.

“The objective presence of the tool only occurs if it breaks during application” (Zics, 2008). This is a rather depressing thought, I think. It makes me feel like people only enjoy things when they are functional – that any beauty in the design is lost instantly should it fail to function. I’d hate to think that anything I have designed or created is viewed like that! I never discard beautiful things just because they are broken. I have several really old camera, old slide projectors, ancient light meters, etc, just because they are cool. I have a box of jewellery which is broken, but I would never throw it out because it is still of value to me – it reminds me of people and places and things – and it always will, regardless of functionality. I think the functions of objects change over time.

Ultimately, I think I must subconsciously consider a lot of these concepts within my own work. I have never taken the time to study them until now, so perhaps I wasn’t aware of the decisions I’ve been making. I started my first undergraduate degree when I was 16 – in film and media studies, and I’ve written a lot about the hermeneutic code. It’s quite interesting to revisit this and apply some of that to technology and design. Have I been doing it all along without realising?

I’m finding all this a bit mind-bending, but it has made me think a lot. I’m going to end this post here and will probably come back and update it in a few days when I’ve had some more time to process all this!