Interactive fluffy piano pillow
OVERVIEW
Utilizing the textile's special and pleasant hand feel, we augmented an off-the-shelf pillow and created an interactive fluffy piano pillow. We demonstrated that textiles can be transformed to touch-sensing interfaces using the double-coating process and thus provide engaging tactile feedback and special emotional connection.
DESIGN DETAILS
We used dip-coated and partially-dip-coated (details here) wool-like fabric for black and white keys and attached them to a pillow (with mesh TPU and ironing). Partially-dip-coating endows electric functionalities to textiles while not undermining the original fabrics' appearance (in this scenario, we kept the white surface of the fabric to be the white keys of the piano). Download our laser-cut files for the piano keys here. What we did is a simple geometry of regular piano key shapes depending on the size of the pillow itself, you may want to adjust the size of our design to suit your pillow case, or design you own radical instrumental interfaces (it does not need to look like a piano at all!).
TECH DETAILS
Capacitive sensing is utilized to capture touching and approaching events. Self-capacitance can be used to realize capacitive sensing. When voltage is applied to conductive fabrics, the fabrics and the earth's surface can be viewed as a parallel-plate capacitor, generating an electric field around it. If body parts are brought close to conductive fabrics, this electric field and the capacitance of conductive fabrics will be changed, which can be detected as proximity or touch events. This capacitive sensing mechanism is shared across all types of conductive materials (copper, aluminum, carbon, etc.), but not only our coated fabrics. In fact, bare conductive provides a great and inspiring article on how this type of sensing works.
We can build a simple low-pass filter and use this capacitive sensing Arduino library to
measure the
capacitance change caused by human body interactions present at the coated fabrics. In the diagram
below, if human hands are brought close to (or touch) the fabric, there would be a add-on capacitance
between pin 2 and the GND (marked with shaded and dashed capacitor). This capacitance change can be sensed
by measuring the time delay of the state change between the send pin and the receive pin, which is
determined by the RC time constant, i.e. R * C, where C includes the additional capacitance caused by touch
or hover. The capacitiveSensor() function in the capacitive sensing Arduino library can keeps
track of the lowest baseline (unsensed) capacitance, and subtracts that from the sensed capacitance,
therefore only return the "added" capacitance caused by touching/hovering.
The arduino code to sense the touch events looks like:
#include < CapacitiveSensor.h >
/*
* modified from CapitiveSense Library Demo Sketch
* by Paul Badger 2008
*/
CapacitiveSensor cs_4_2 = CapacitiveSensor(4,2); // 1 MOhm resistor between pins 4 & 2, pin 2 is sensor pin, connect conductive fabric
void setup()
{
cs_4_2.set_CS_AutocaL_Millis(0xFFFFFFFF); // turn off autocalibrate on channel 1
Serial.begin(9600);
}
void loop()
{
long total1 = cs_4_2.capacitiveSensor(30);
Serial.println(total1); // print sensor output 1
delay(10);
}
The result serial plotting would look like:
We implemented the code and the circuit with Arduino ⬇️. One thing exciting about having our coated fabric instead of other conductive materials, say, copper foil, is that with coated thick fabrics, our capacitance-based sensing is also capable of sensing pressure.
To sense the hovering interaction, we can replace the 1MOhm resistor to a larger one (e.g. 5MOhm), and the arduino code looks like (we added a window filtering to produce smoother readings):
#include
/*
* modified from CapitiveSense Library Demo Sketch
* by Paul Badger 2008
* and also the Arduino smoothing example
* https://docs.arduino.cc/built-in-examples/analog/Smoothing
*/
const int numReadings = 10; // window filter length
int readings[numReadings]; // the readings from the analog input
int readIndex = 0; // the index of the current reading
int total = 0; // the running total
int average = 0; // the average
CapacitiveSensor cs_4_2 = CapacitiveSensor(4, 2); // 10 megohm resistor between pins 4 & 2, pin 2 is sensor pin, add wire, foil
void setup() {
cs_4_2.set_CS_AutocaL_Millis(0xFFFFFFFF); // turn off autocalibrate on channel 1 - just as an example
Serial.begin(9600);
for (int i = 0; i < numReadings; i++) {
readings[i] = 0;
}
}
void loop() {
// subtract the last reading:
total = total - readings[readIndex];
// read capacitance
long cap = cs_4_2.capacitiveSensor(80);
readings[readIndex] = cap;
// add the reading to the total:
total = total + readings[readIndex];
// advance to the next position in the array:
readIndex = readIndex + 1;
// if we're at the end of the array...
if (readIndex >= numReadings) {
// ...wrap around to the beginning:
readIndex = 0;
}
// calculate the average:
average = total / numReadings;
// send it to the computer as ASCII digits
Serial.println(average);
delay(10); // arbitrary delay to limit data to serial port
}
The result serial plotting would look like:
You can definitely build this application using the method of Arduino. But we used a much simpler arlternative... the Touch Board by bare conductive! It's much more expansive and often sold-out, but it's simple and easy to use. You can find the tutorial here. We just use silver fabric segments to connect pads from the board to our coated fabric. This board only has 12 pads, so we did not connect all coated fabrics on our pillow -- just middle ones are connected.
OUTCOME
