Final reflections: Which theories were useful and what did I learn?

Looking back on our discussions and articulation when designing and testing the lamp, the following theories stuck out to me as especially useful:

In my post on the text Aesthetic Interaction — A Pragmatist’s Aesthetics of Interactive Systems by Petersen et al. I wrote that the text taught me that I should have self-expression in the human in mind, and allow for improvisation and play. I feel that this was a common theme especially when testing the interaction of the lamp. Does the lamp feel alive? Does the interaction with the lamp encourage you as a user to express yourself through the interaction. This helped us articulate the fine tuning and testing of the code.

In my post on the text “Giving form to computational things: developing a practice of interaction design” by Anna Vallgårda (2014), I was introduced to this model:


I felt this was useful when considering the cohesion between the three form elements. It served as a nice constant reminder, that not only should we design the physical form and the temporal form with code, we also needed to make sure the user understood how to interact with the lamp. This ultimately led to the design of the trigger shown below:


In that way, it has positively surprised me how useful that theory was for me, contrary to my initial belief.

Looking back on the text “Microinteractions, designing with detail“, a word that we have used a lot in our conversations is trigger. This word was a good description what ended up being the blow-hole shown in the picture above, and thus was used often in our conversations. The word feedback played a fairly big role to us as well, since most of the temporal design of the lamp, directly involved feedback from the lamp to the user. We did not really use the rules and loops part of that text.

The text “Design of Everyday Things” served us in mostly the same way, in regards to signifiers, affordances and feedback.

The article “Exploring Relationships Between Interaction Attributes and Experience” actually gave us quite a few good words and tools for articulating the interaction when designing. While my initial critique of the model was that the words were un-precise and vague, a lot of them actually served us in a nice way. While we never plotted our different versions of the lamp in the matrix and directly analyzed the differences with it, many of the words were used in sentences like: “Can we make it slower?“, “Can we make it more precise?” “It should feel more powerful and not as gentle.

In the blogpost about the article in question, I wondered:

“It is also also unclear whether they are meant to represent truth, or represent a way to discuss a design. I think it is more suited for the latter.”

I think now, looking back, that the model and terms were actually a lot more useful for articulating interaction and discuss design, than I had initially imagined.

Over all, I’m positively surprised how much of the theory we actually used when discussing our design. It helped us establish common grounds in which we could help each other explain our thoughts of the design, and what could be improved.

Below I will reflect on milestones and learnings throughout my journey with the bonfire lamp:

Looking back at my first tries with both the physical and digital part of working with arduinos, I’ve really come a long way. Starting out by simply making a few LED’s flash by pressing a button.

In the post after, I tried working with a piezo-sensor by cutting and pasting small pieces of code from other projects and tutorials. Here I encountered a problem that made for a valuable lesson later. Check your wiring/soldering and check if the sensor works.  We never really got that one to work, and we wasted a lot of time trying to tweak code for a faulty sensor.

In the post Further sketching and refining interaction I learned the value of coding an average function, to filter out noise from (faulty/bad) sensors. We would later scrap this part, and then add it again in the final version of the lamp.

In Working on the temporal form we learned about the millis function, that proved to be invaluable for the final temporal form of the lamp. Furthermore we started sketching and already at this point, found the shape that would end up acting as a trigger onthe final form of the lamp.

In Working on the physical form we started exploring the shapes that would end up turning into the final shape of the lamp. While I think the physical form of our lamp turned out great, it occurs to me now, that we could have relied more on “Giving form to computational things: developing a practice of interaction design” by Anna Vallgårda to base our shape more on theory. So that might be a learning for next time. This might have helped users having an easier time understanding the interaction of the lamp intuitively.

In Sketching with Arduino and a temperature sensor we explored a new kind of sensor, rewrote most of the code and started concerning ourselves with the responsiveness and magic of the interaction with the lamp.

In Now we’re talking – Air Quality Sensor we switched to yet another sensor, this time for good. Had we had this sensor from the start, we would have had an easier time coding the project faster, but it made for some nice learning experiences trying out lots of different sensors and exploring their individual qualities. The piezo is a simpler sensor, but also less precise. The temperature sensor was more precise, but vulnerable to fluctuations in room temperatures around it, and it also reacted slower than we liked. Finally the gas sensor was complicated to get to work, since we had to install a library with data set to make it work, but once that was done, it was both precise and fast. Only downside was the 24 hour warm up time, which we overcame by employing the average function mentioned earlier.

In Final decisions on physical form we tested other kinds of triggers for the sensor, but ultimately ended up going with our first idea of the phone-like holes.

In Temporal form: Fine tuning the code we spent further time getting the coding, and thus the feel of the lamp right. We explored flickering light as a way to make the lamp feel more alive, but scrapped that idea after testing it in practice.

In Reflections on the code before the big day we looked back on our code, and with all the stuff I had learned about coding a temporal form, I envisioned a clear way to improve the code, should I rewrite the entire thing. This was a very fulfilling experience, to see your own improvement in such a way.

Over all, this has been an amazing and giving experience. My main objective with this course was to learn how to sketch with arduino boards, and I very much feel like I accomplished that. On top of that, I now have an entirely new vocabulary when it comes to interaction design, and a great project to show off at the top of all my future portfolios.




Reflections and reactions from the exhibition

After a successful exhibition of the lamp it’s time to reflect.


First of all, the lamp was really well received. Most people found it fun and liked the looks. We got a look of surprise and joy from most people who tried it and got it to work.

When you observed people using the lamp, it became very clear that to blow into the hole, you have to hunch over a lot in an awkward manner, the lamp pretty much demanded that you humbled yourself before it to turn it on. Afterwards when the lamp lit up, it felt powerful, to have achieved something after exposing yourself.

Many people complimented the looks and the finish of the lamp. Some commended the details with the combination of wood, leather string and plastic, and told us that they liked how the leather string connected the plastic part of the lamp to the wooden base. They found that it fit well with the organic materials, in regards to the idea of the lamp being inspired by a bonfire.

It took a bit of skill to use the lamp. Some people immediately figured out how to blow the right way to make it light up, while others struggled to get the sensor to register the blowing. Once people got the hang of it, they could make it light up consistently. We liked this part, in that it actually takes a bit of practice to use it, just light turning on a real bonfire.

A small issue we discovered with our design, was that people thought they had to blow in the small gaps of the plastic. If we were to do another iteration, we would have to look into closing these holes.


Otherwise the exhibition was a very positive experience, and we’re all happy and satisfied with how the lamp turned out.

Reflections on the code before the big day

The lamp is now ready to show off to the world.


After letting the sensor warm up for 18 hours, it is now a lot more responsive to user input. We tweaked a few values of the code to make the lamp feel as alive and give immediate feedback, and not delayed. This is vital to make the lamp satisfying and fun to use.

Below are the final values we ended up with:

// interval at which to fade (milliseconds) (1000 is a good value for real life use)
const long reduceInterval = 130;
// interval at which to increase the LED intensity (milliseconds)
const long increaseInterval = 40;
// Defines Threshold for when to increase light
float threshold = 8.0;
// Change this to edit the speed at which the LED loses its light
int fadeAmount = 1;
// Change this to edit level 1 intensity increase
int increaseAmountOne = 1;
// Change this to edit level 2 intensity increase
int increaseAmountTwo = 2;
// Change this to edit level 3 intensity increase
int increaseAmountThree = 2;

The threshold for when to increase the light ended up at 8, so as not to make the lamp too sensitive, but not require too much effort before reacting. Setting this value too high, often ended up feeling bad to whoever used the lamp, since it felt like the lamp was just not working or reacting to input at all. So it was better going with a more sensitive setup to ensure a good experience and encourage more interaction with the lamp.

We left the fade amount and intervals of fading and increasing at the shown values. For a real life setup in a livingroom or bedroom, a reduceInterval of 1000 ms might have been more ideal to slowly fade over a longer time. But since we are showing the lamp off in an exhibition-setting 130ms seemed like an appropriate time frame, fading the lamp from fully lit to turned off in about 30 seconds.

We also ended up removing the last tier of intensity-increase, so that a big sensor-reading wont end up lighting up the lamp completely.

Reflecting on how our code is written, I think we could have gotten a more smooth and controllable interaction with the following setup, written in pseudo-code:

Brightness has a value of 0-10000 (instead of the current 0-255)

increaseTierOne = 10

increaseTierTwo = 20

increaseTierThree = 30

Map Brightness value to 0-255

Send brightness value to LED lightbulb

The values would naturally need tweaking, but this setup would allow us more detailed control over the increasing and decreasing of the brightness of the lamp.


Photo shoot

Yesterday we also had a proper photoshoot of the lamp where we tried to capture the both the interaction gestalt, the physical form and the temporal form. I think we succeeded in showing as much as possible in the four pictures. The only part not shown, is the lamp slowly fading over time.

Temporal form: Fine tuning the code

Since the physical form of the lamp is now complete, the only thing left to do is getting the code and sensor to work together as we want it. These form the basis of the temporal form, and for the lamp to feel satisfying and interesting to use.

What we’ve been doing to achieve this, is fine tuning the different constants in our code. The end goal of this is to make the response from the lamp instantaneous, so the moment you blow, it increases brightness, and stops increasing brightness as soon as you stop blowing. Due to the nature of the gas-sensor, it’s difficult to get the response as precise as we want. Especially since it makes a big difference whether the user blows close to the sensor, or far from it.

We settled on a specific distance from the lamp, that felt most intuitive to the people we asked to test the lamp. By tweaking the constants of our code, the lamp now responds fairly precise to blowing (and not blowing), but there are still fluctuations that we don’t know how to fix. We’ll try to look into that before our exhibition day and see if we can get it just right.

This is how the constants look now:


// named constant for LED pins
const int ledPin = 5;
// interval at which to fade (milliseconds) (1000 is a good value)
const long reduceInterval = 130;
// interval at which to increase the LED intensity (milliseconds)
const long increaseInterval = 40;
// Defines Threshold for when to increase light
float threshold = 7.0;
// Change this to edit the speed at which the LED loses its light
int fadeAmount = 1;
// Change this to edit level 1 intensity increase
int increaseAmountOne = 1;
// Change this to edit level 2 intensity increase
int increaseAmountTwo = 2;
// Change this to edit level 3 intensity increase
int increaseAmountThree = 3;

To make the lamp get a more living feel, we also tried adding a random function to the brightness output of the lamp, as to simulate the flickering of a candle light. However it ended up feeling way to violent, especially at the lower light levels, since the difference is way more visible at those levels. (eg. difference between 0 and 5 is huge, since it goes from turned off, to turned on and quite bright). So we ended up scrapping that part of the code ultimately.

The devil is in the detail


The lamp is now fully functional and tied together. We faced a challenge earlier on, with the glueing-flaps casting hard shadows on the inside of the lamp. To solve this issue, we embraced this problem and tried to turn it into something visually pleasing.

To tie the physical form more to the grounded and natural origins of the lamp (the bonfire), we used a raw looking leather string to tie together the flaps on the outside of the lamp.

To further build on the concept, we dyed the wooden base of the lamp, a darker color, to make it feel more like the charred base of a bonfire. All in all, I feel we achieved a good mix of a natural bonfire-like shape and a harder geometric look.


In accordance with the above model, the physical form now supports both the temporal form and interaction gestalt of the lamp. It suggests the form of use, and supports the abstraction, that the lamp is half-lamp, half-bonfire.