Archive for category Doing

Date: June 22nd, 2011
Cate: Doing

DOING: Max MSP – Fragmentation

The theme the Max MSP doing module was “fragmentation”. To me, “fragments” suggest fragments of memory, or remembering fragments of things, so I wanted to make something that would record snippets of the user’s life.

The first thing I had to do was establish precisely what aspects of someone’s life I was trying to capture. What parts of your day are actually worth savouring? It’s not gonna be things like buying milk, watching TV, or cooking dinner… you’re going to value more important things than that. So I decided to capture moments when the user experiences an emotional surge, ie. when they are excited, or distressed, or nervous.

To do this I created a circuit which uses an LED and an LDR to pick up your heart beat. It works by detecting the change in density in your finger; when your heart beats, your blood pulses into your finger and it momentarily becomes denser. Between pulses, the blood flows out and your finger becomes more transparent.

The LDR detects these minute changes in density. I used Arduino2Max (as, after battling with both for a while, it seemed decidedly more simple than Firmata etc!) to read in the values from analogue port zero.

So basically, my Max MSP patch reads in the analogue pin and, when the pulse hits 80 beats per minute or above (the approximate “elevated heartrate” for an average person), it records a 5 second snippet of video and sound. These are all saved, with the idea being that you could look back through them and have a record of fragments of your high and low moments. What I really like about it, is that you might not even be aware of some of them; you could look back through your day and find little fragments you weren’t aware were making you feel particularly happy or sad.

Here is my patch in full, please excuse my tragic face, I am full of the cold!

And in presentation mode, with the playback/viewing window becoming more of a feature:

I think the idea could have some nice applications within wearable technology. A rough concept I thought of would be for a “memory hoody”… sew a small camera into the front of the hood, run the sensor down out of the sleeve, and you could capture memories all day. The circuitry could be stored in a small pocket somewhere on the hoody.

All in all, my Max MSP experience hasn’t been as bad as I thought it would be. I found it a bit frustrating at first, as everything I do is very physical, and everything I thought I wanted to do with Max would have been much better realise with another program, so I had to really think hard about what I wanted to achieve. I never really do anything screen-based, so this was a first for me. I even managed to put aside the electronics to concentrate on the patch!

Things I would have liked to have done include adding a timestamp to the videos, and maybe a more comprehensive playback/viewing screen and controls. I think I’ve done okay though – I wanted to interface with Arduino, which I managed, and I did achieve the objectives I set out to.

Date: June 16th, 2011
Cate: Doing

Max Circuitry

Battling with my Max assignment a little bit. I’m using a technique/input I’ve used before, with an LED and an LDR in a circuit. The LED goes on one side of your finger, and the LDR is on the other and can detect the change in density of your finger and therefore your heartbeat.

My circuit is working okay, and I’ve got the analogue pin reading into Max. I’ve then read that into a slider which splits the signal, and outputs a bang for the range of heartbeat I want (above 70bpm), which will hopefully trigger a short recording.

I currently can’t get it to actually RECORD anything. I can take a picture, control a slideshow, etc etc… just can’t record yet. Yikes. More work to do.

Date: June 13th, 2011
Cate: Doing

Doing: Max MSP

Cracking on with my Max MSP assignment. Unfortunately my Max MSP trial has expired so I’m back down to Earth with a bump and am wrestling with PD again :(

The theme is “fragmentation” which made me think… fragments of something. I’ve lost marks in the previous two assignments for having too loose a relation to the designated theme, so I’m gonna get this one right. To me, personally, hearing “fragments” makes me think fragments of memories, or remembering little bits about things. So that’s what I’ve been running with.

I’m a very hardware-based designer so I’m looking to create something wearable that records fragments of your experiences to convert them to ‘digital memories’. Watch this space.

Date: April 28th, 2011
Cate: Doing

DOING: Processing

CONCEPT

“Abertrack” is a Processing program and visualisation which tracks and plots the voy- ages of an international oil tanker called MV Aberdeen. Ship location data is provided by a service called “Ship AIS” which provides regular updates, including the latitude and longitude of the vessel. As my partner works at sea, I regularly check Ship AIS but often find the information confusing. There is an option to view the vessel position on a map, but it only shows the previous 6 hours of movement.

I wanted to create a nicer, more aesthetically pleasing visualisation of the MV Aberdeen’s movements over a longer period of time.

IMPLEMENTATION

When I embarked upon this project, I wanted to pull the vessel’s location data from the Ship AIS system via XML feed, however this proved to be an insurmountable feat. Most sources did not have an XML feed that Processing could read, and the only one I could find required a fee of several hundred pounds to access. However, I expect with enough time – and perhaps some outside advice – I could eventually overcome this problem by reading the val- ues straight from the PHP cell on the website.

After several weeks of battling with the above, I opted to manually store the data in a text file. I then called this into Processing as an array, with each line (latitude, longitude) being parsed as a string. This was an easy workaround and allowed me to achieve what I had set out to. For each string, I drew an eclipse to mark the co-ordinates of the ship at that time. Once I had my co- ordinates plotting correctly, I joined them with a line.

The biggest challenge I faced in this project was plotting the GPS co-ordinates onto a 2D map. It took a lot of research into mercartor maps, a distressing amount of maths and rather a lot of trial and error to finally come up with a solution which enabled me to plot GPS co-ordinates directly onto my map.

SCOPE & POTENTIAL

There is potential for this concept to be scaled up to create larger and more engaging visu- alisations. This example shows a mock-up of three different vessels in three different seas, in different colours.

There is also potential to make the map interactive, for example allowing the user to zoom in on specific areas or choose which ships they view. A live feed would be nice.

MYTHS

As inevitably predicted, I’ve gone for a very loose connection to the theme of “myths”!

When hearing people talk about myths, it is often sea-related things which spring to mind, eg. mermaids, the Loch Ness Monster, the Greek God Posiedon, etc. One of the most famous myths is based around the Chinese Ocean God T’ien Hou – a mythological being who guarded sailors and kept them safe. She would watch over sailors and ensure they were always safe on their voyages. Arguably, tracking vessels ensures their utmost safety and security – so my project relates to the theme in this way.

You can view the A3 poster I made to accompany the project by clicking here.

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 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: November 28th, 2010
Cate: Doing, Inspiration
1 msg

Hacked Technology

Class

Last week in uni was amazing. We were lectured by Lalya whose interests seem to line up with mine really well. Several of the projects she showed us are things I’ve researched a lot in the past and it was great to see someone else in the same sort of place as I am, idea-wise. It was also amazingly refreshing to hear it all coming from a fellow girl – my undergraduate degree was 100% male driven and sometimes I felt that it means my ideas weren’t responded to in the right ways.

Taking things apart has always been one of my interests so I was really keen to get stuck in. I was paired with Will and John and we bounced ideas off each other (some more whacky than others) and became mainly fascinated by a tiny guitar. Can’t say I’m keen to hear the Hannah Montana theme music ever again.

Tiny guitar

Unfortunately life got in the way, emails were not replied to and we never ended up meeting up to finish the project. I then went to Spain for a long weekend so my individual “recyled object” ended up being limpet shells which lit up. Not very technological, but hey, gotta work with what you’ve got! The idea was inspired by a simple project I saw on Instructables years ago. I think I’m going to turn them into fridge magnets :)

Limpet LEDs

« Older Entries