slowscreen

Slowscreen 1
thermochromic display of information

I’ve been working with Pauline Gourlet on this project for a few months now, and it’s finally nearing the end. This post is a short account of how this idea came to be, from the first rough circuits to silkscreen-printing the fabric and finally connecting and programming with arduino. Another post, one that is focused on actually using this display and exploring it’s potential in real-world situations with users is coming later.

short abstract

Slowscreen is a black capacitive fabric screen, reactive to the skin temperature. Embedded in the home — furnitures, walls, pillows or curtains — these sensitive areas become expression spaces between housemates. Temperature becomes a language for interaction, as a witness of each other past presence. The ephemeral imprint evokes Rorschach inkblots, open to interpretations. This calm technology aims to integrate the usual complexity of information in the texture of everyday life.

first ideas and development

This project started in mid-November when Pauline printed a large square of fabric with thermochromic black ink. At around 27°C, this micro-encapsulated ink turns invisible and shows the fabric’s color (in our case, white). It is very fragile though, and can only last a few thousand cycles. Our own black ink has lighten up quite a bit since it had been printed, due both to its limited lifespan and to normal exposition to the sun’s UV rays.

Seeing this surface and the fascinating reaction of the ink to the touch led us to wonder what would happen if we could remotely and automatically display shapes, letters and pictograms on it. One approach was to have some kind of RC car move on top of the fabric (think Seymour Papert’s Turtle with a heating element instead of a marker) but it defeated the calm and wonder people would feel while interacting. Also, touching the display wouldn’t be possible while it was being printed.

Ironing fax paper often creates fantastic results. This “print” was done a few years back but it is relatively close to what we can get with Slowscreen. Slowscreen 1

We started with very simple experimentations with resistors placed in a grid. They worked somehow, but took a lot of time to heat up and stayed hot for a while because of their size and material (though strangely, ceramic is supposed to have a high thermal conductivity, so this shouldn’t be a problem). You can see some of these tests on Pauline’s website.

In the end and thanks to suggestions by a bunch of people, we settled on resistive threads to heat the fabric. We also used copper threads to conduct electricity where we didn’t want to heat it. Huge thank you to Hannah Perner-Wilson for helping us create the first working prototype.

Schematics of the matrix. The two sides of the fabric are used as insulator, since the threads are bare. Diodes in the top left corner are necessary because of the current flow. Schematics Slowscreen First prototype with copper and resistive threads. Connections between the threads are done with pearl beads. Slowscreen 1

According to Joule’s law, P=R*I*I where P is the power dissipated in the form of heat, R is the resistance and I is the intensity of the current. Basically, the higher the resistance the higher the temperature. Copper is among the least resistive material to current (see this great Wikipedia article) while resistive threads like the one we use is much more resistive (27 Ohm / meter). So the heating mainly occurs where there is resistive threads.

scaling up

Experimenting with this setup convinced us we could translate our findings to a bigger scale. We defined a 37.5 x 54cm screen that was made of 750 modules: the matrix would be for 25 * 30 “pixels”. This also means we needed 750 diodes, 40 meters of resistive threads, 30 meters of copper thread and 2500 pearl beads.

750 modules seemed reasonable at the time… Slowscreen 1

But this is just the material for the fabric. We also use 55 MOSFETs transistors (irl540) to interface with high intensity current, 8 ICs (74hc595) to control these transistors and one arduino to drive everything. Also, an external power unit but it is not clear yet how much power we will need. So far 1 amp has been enough to light up a few modules at once but we will have to step it up if we want to heat hundreds of modules at once.

Full schematics of Slowscreen. Click for huge version. Missing is a pull-down 10k resistance between the transistors and the ground, not shown here because of space constraints. Complete Schematics Slowscreen

The schematics may seem complicated but it’s actually really simple, just very repetitive. I am not sure yet how I am going to put all this stuff in a neat and tight little package to go with the fabric but I will have to think of something soon enough…

final version — what is done

We started by carefully choosing the fabric we would use. Its stitches needed to be big enough to be sewn with copper threads, while not being too elastic or flexible to strain our circuit too much. Also, thick enough to insulate the threads. We opted for a black fabric from the marché Saint-Pierre. We then silk-screened on both sides: on the underneath, all the reference points to sew exactly where we needed to and on the front side numbers and letters to designate coordinates to help in programming (also, it looks really good :)

White ink on black surface is never easy but this particular ink is really dense and opaque. Silkscreen The shift in the prints on the front and the back is less than 0.05 cm (a huge feat on fabric). Props to ENSAD’s silk-screening technicians! Silkscreen Told you it looked good :) Slowscreen 1

Now that we had the fabric, we could start to sew the modules! Over the last few weeks, Pauline has made about 500 modules. She is doing this tedious job while I take care of the also-tedious-but-probably-not-as-much task of doing the electronics and programming. She sent me a 4×4 matrix a few days ago so I could play around with it and implement the schematics I drew.

The connections are made under the fabric : 3 beads, 1 diode and 5cm of resistive thread for each module. Copper threads (in orange) connect everything together. Grey ribbon cables go out to the transistors. Slowscreen 1

Unfortunately I only have 5 MOSFETs with me, so I can only test a single row of 4 modules. Still, I connected them to an IC instead of doing it the easy way by plugging them to arduino directly. I will have to use ICs anyhow for the final design, so I might as well start to use them now.

Under the surface, the electronics. You can see the ribbon cables leaving the fabric and separating on the breadboard to the MOSFETs transistors. Slowscreen 1 Connecting and insulating the connections between the ribbon cables and the copper threads with electrical tape. Slowscreen 1 Close-up of the circuit on the breadboard. The external power is a simple USB port. Slowscreen 1

pixel patterns

After hooking up everything and almost destroying my arduino two or three times (also, my arduino has recently gotten the ability to crash my laptop with a kernel panic, so every export of a new program is kind of a russian roulette), I could now try a few different patterns on the fabric. Unfortunately, having only a few transistors with me (and just one breadboard — I probably need another) I couldn’t display complicated shapes or animations easily. Next step is going to be buying more MOSFETs and using them to control my 4×4, so I will have 16 pixels to play with. Much more fun than a single 4 pixel line… Still, I documented a bunch of shapes I could create.

I can only control one row at a time. But since the fabric stays hot for around 20 seconds, I can rewire to another row to give the impression that I control the 16 pixels :D Pattern Slowscreen Close-up of a module while it heats. Each time one module heats up, the ink reacts a little differently. Slowscreen 1 A short video, showing how fast it heats in real-time. Room temperature is around 20°C.

what is left

A lot of things. First, working on an interface to make it dead simple to animate the display. So far, to control which module I wanted to “light up” I had to send a number that would then be interpreted in binary.


int refbytes[] = { 128, 64, 32, 16 };  

[…]

for (int i = 0; i < sizeof(refbytes) ; i++) {
    digitalWrite(latchPin, LOW);    
    shiftOut(refbytes[i]);  
    digitalWrite(latchPin, HIGH);   
    delay(1000);
}

That is completely non-intuitive. There is something to be done with the specificity of this surface in mind: it animates all the time, it cannot heat too many modules at once, when modules heat for too long they overlap, the ink takes longer to reappear if the module has been heating it for a long time, etc. Very, very interesting constraints that deserve a lot of attention.

I have recently gotten a raspberry pi and installed a Node.js server on it. Simply put, I could replace the computer that connects to arduino by a raspberry pi and connect it to the internet. With Node.js running on it, I could send and receive information from and to the display at all time, anywhere. This seems ideal. Essentially, this means that anybody could go to a website, see the state of the display, and click and heat the modules in real-time.

Another thing we have experimented Pauline and I is switching the modules to "capacitive sensing". Each modules then becomes a sensor for detecting static electricity generated by the human body. Ideally, we would have the full 25 x 30 resolution to know of finger's and hand's movements on the surface of the thermochromic fabric. Detection works through the fabric, so users wouldn't even need to see/touch directly the circuit. There's a chance we can both emit heat and sense presence by alternating between these two modes very fast, but I have some doubts about this. This could be tried later on.

There is still some unknowns (mainly on the programming part) but overall I think most of the work is done. I don't think I ever had the opportunity to create the surface I would work on later on so it feels good when it starts to become a reality. As a designer, I have spent most of my life using/investing platforms that were already defined, limited by decisions I didn't take. Sure, constraints are necessary to stimulate creativity but in this project, there is a sense that we can choose which constraints we want to impose and which we don't want to have. I guess the next step, when the technology is viable and clearly documented, would be to invite other designers and users to try and use it the way they see fit. I am really curious to see what other people can do with this project.

Comments are closed.