About my blog

The aim of the ITD course (ID4220) at the Delft University of Technology is to provide Design For Interaction Master students with in-depth theoretical and practical interaction design knowledge to help develop future products based on user-product social interaction. ITD proceeds through a sequence of iterations focusing on various aspects of the brief and the design, and culminates in an experiential prototype.


This blog is managed by Walter A. Aprile: please write if you have questions.

Archive

Disclaimer

De meningen ge-uit door medewerkers en studenten van de TU Delft en de commentaren die zijn gegeven reflecteren niet perse de mening(en) van de TU Delft. De TU Delft is dan ook niet verantwoordelijk voor de inhoud van hetgeen op de TU Delft weblogs zichtbaar is. Wel vindt de TU Delft het belangrijk - en ook waarde toevoegend - dat medewerkers en studenten op deze, door de TU Delft gefaciliteerde, omgeving hun mening kunnen geven.

Posted in July 2011

The evolution of The Patch

During
the ITD project, our Max patch has gone through some radical changes. It has
evolved from a simple input output patch to a full grown patch containing
several different functionalities.

Having
arrived at the end of the project, we thought it would be interesting to
discuss this progression, as well as evaluate the use of Max. That is what this
post will be about.

 

The first
steps

Having
had no prior experience with Max as a programming tool, I started with a simple
patch for our concept in the first cycle – the sensor chair.

As
you can see in the image below, the patch is fairly straightforward an contains
only a small number of objects.

The
most challenging part in building this patch was to make an “if/else-statement”
using the visual programming language of Max instead of the cold logics of a
language based programming language.

 

Towards
maturity

As
we progressed towards a final prototype, the Max patches also grew more
complex. At first, we still transferred messages through one computer. We had
two separate patches, one for each concept, and we connected the prototypes to
two separate ports of one Arduino. An example of these patches can be seen
below. Two drawbacks of these patches are that 1) they are not generic and
therefore had to be synchronized all the time and 2) the messages could still
not be sent over the wireless network, which was our ultimate goal.

Notice
that this patch contains a Phidget interface kit and a Maxuino interface. This
last element was used to communicate with the Arduino in the concept. This
provided us with the handles to use the pulse width modulation of the Arduino
and still be able to use Max for the programming.

 

However,
we still had to incorporate sending and receiving messages over the wireless
network. This was done in the next iteration cycle, of which the patch is shown
below.

Apart
from the addition of message transfer, the Phidget interface kit was removed.
Instead, we used an Arduino shield, which was made by Rob Luxen. This enabled
us to make the prototype smaller and made it possible to use just the Maxuino
interface to collect sensor data and send both digital and analog outputs to
the Arduino board.

 

The fully evolved
Patch

Since
this patch is somewhat chaotic to someone who is not familiar with the patch, I
started cleaning up the patch. First by using sub patches which I saved in
separate files and then by making patchers in the main patch. The latter
approach proved to be more practical, because the patchers were accessible from
the main patch straight away and instead of having to open a separate file.
Apart from that, the changes made to the patchers are incorporated straight
away, whereas changing elements in a separate sub patch file required
restarting the main patch for the changes to take effect.

To
make the patch more structured I made the division in the patch more clear by
separating the different parts of the patch that are related to a certain
functionality using panels. The result of this iteration can be seen below.

Evaluation

This
patch is the final result of half a year of working with Max/MSP a programming
tool. Given the fact that I had no prior experience with Max I can say that I
have come a long way in learning how to use the language.

In
the beginning I sometimes had no idea where to start in building a
functionality. At the end of the project, on the other hand, I had arrived at a
point where most of the times I could directly pinpoint the cause of a certain
malfunction of bug in the patch. At last I also knew in most cases which
construction of Max-objects I needed to solve these problems. Concluding, I can
safely say that getting familiar with Max took me quite some time, but this
paid off in the end: I have learned a new programming language which I think
can be a benefit in building interactive prototypes.

However,
I think that for making a stable piece of intelligence for a product, it is not
the most appropriate tool. This is mostly due the fact that, when building a
patch in Max, you tend to build one problem fix upon another. I think this is mostly due to the iterative style of programming which Max supports so very well. However this leads to
either new problems or an ever more complex patch. In order to solve this, the
best thing is to start again from scratch, but then it is not always simple to
incorporate all the intended functionalities in a clean way straight away. On the other, language based programming,
on the other hand, makes it easier to re-use code fragments.

In
our case it did not matter though; the prototype has worked throughout the
exhibition without becoming instable.

 

Tim
Overkamp – programmer Generation Y1

`The Happy End`-Movie

And-this is the last post from toolkit group.We hope you enjoyed with following our works during the semester.

Last words are from our movie and here is the link:
 
http://www.youtube.com/watch?v=74OS2v9Htyw
 
Enjoy!
Toolkit group (only one) 
 
 
 
 
 
 

Exercise1, our final concept: FLEXCURE

At the end of the project we presented our concept on the exhibition day. Also specialists that were involved earlier in the project, were enthousiastic about our concept ‘fitting the trend of using more interactive and therapy supporting healthcare products. See our latest video showing our final concept and prototype "flexcure":

YouTube Preview Image 

The complete story…

Here is our final movie of the process and the final concept…ENJOY!

YouTube Preview Image

check http://www.youtube.com/watch?v=DLj3xFI_OAI 

Movie

Summarizing
 
 
YouTube Preview Image
 
 
If it does not work see: http://www.youtube.com/embed/-SR9fAtNvd8?hl=nl&fs=1
 
 
Happy Holidays, Team Happy 3

Week 20 – Exhibition and Process

Final exhibition

Here is the final movie, which concludes concept, process, prototype and exhibition.

[object:flash:http://www.youtube.com/v/qkqKjWhxy3Y?fs=1&hl=nl_NL width:480 height:390]

 We have enjoyed a great semester with nice teamwork. Thanks for your attention. 

 

 

Poster for exhibition

Brochure for exhibition

Final prototype

The following is the picture of final prototype.

 

 

© 2011 TU Delft