Touch me or not

The textile remembers where your touch it.

Find the process documentation here.

Origin story

Physical contact is an intimate feeling. When is it a welcome feeling, and when an uncomfortable experience? How does someone or something feel about their encounters with physical touch- affection, invasion, approval, comfort, abuse, or something else? And what is the conversation like, between both the parties involved, one touching and one being touched?

TouchMeOrNot addresses this unspoken conversation between the two agencies involved in physical contact, through sensing it, showing it, and seeing it.

How do I imagine this conversation taking place?

I started visualizing spatially, the exchange of information- How the act of touching might happen? How is it sensed? How is it shown? How is it seen?

To put these into the framework of LED containing soft-circuits, I landed on the following:

• How might the act of touching happen? How is it sensed?
Through pressure sensors (Velostat). A pressure sensor matrix can help determine the position of the physical contact, as well as the force behind it.

• How is the sensed contact shown? How is it seen?
It is crucial that the location of the physical contact is not just sensed at that place, but also shown. After all, it is about communication, and that involves an exchange. Hence, as a response to the input matrix of pressure sensor (Velostat), can I have an output matrix of LED lights?

It is not just about the textile made of soft circuit sensing touch, but the one doing the act of touching is to be made aware.

Moving onto addressing initial questions of implementation:

• Which microcontroller board to use?
I am leaning towards Teensy LC ➚, considering the number of pins it has (specially analog and PWM pins). And the two matrices will need maximum flexibility with the microcontroller pins. In addition to the pins, it uses Arduino’s software and code which I am familiar with (albeit barely) as compared to Raspberry Pi, hence debugging might be easier. The 3.3V power is a concern considering an LED matrix, and will need to be tested.

• What materials to use to make the soft circuit?
Look: Something I am always inclined to address in any technology / machine is the lack of transparency, or rather a need to hide the work. Especially with E-Textiles, it is easy to hide the work in various layers and sneaky materials. Textiles are highly versatile tools. And With great power, comes great responsibility! So, how about instead of using the materials to conceal the work and focus on exterior finishing, we use the properties of materials that can enhance transparency?



As much as it will be difficult to sew on a sheer fabric, I want to start with using the textiles to focus on the principle of showing your work and address the implementation challenges as they arise (which they certainly will.) Why can’t the soft circuits look like these?



Materials: Linen is a highly versatile material, that can result into a myriad of textures and feels: open-weave, dense, blended with silk to feel shinier, or unblended to feel grainy, and more. And considering the fineness that might be needed to use a number of inputs and outputs with the tiny teensy pines, it might be wise to go for the classic running stitch on the linen sheer fabric, rather than fused fabric trace or complex embroidery stitches.


sheer linen fabrics

• What will be the size of the two matrices?
In a Teensy LC I can get various combinations of PWM, analog, and digital pins. I can comfortably make two 5x5 matrices if I only need one set of analog/PWM pins vs digital pins. Or, go for 3x3 matrices, if for either of the matrices, I need two sets of analog pins. This will depend on when I learn about the code to make up the matrices.

• What will the layout be like?
Since it is going to be highly difficult to sew on a sheer fabric as it is, it might be wise to have separate layers for all the matrices. And it also metaphorically speaks to the hidden layers in technology.


Layout of layers for 5x5 Matrix

Implementation

Testing the matrices with Teensy
Since the outcome depends on two matrices, the first step was to understand how an LED Matrix works. The 3.3V capacity of Teensy LC to support at least smaller of the two matrices planned (3x3 and 5x5) can also be tested simultaneously with this first prototype.

The super helpful people at MultiWIngSpan ➚ made it possible for me to build the LED matrix, as well as manipulate it!


test circuit for the matrix


test run for the LED matrix

I turned one LED at a time, sequentially, to not just test whether each one can be turned on at command, but also understand the sequence in which they are read in a code.

Following are some of the other references helpful in understanding and building LED Matrix!

• https://create.arduino.cc/projecthub/shahbaz75sb/8x8-led-matrix-interfacing-with-arduino-daec65 ➚

• https://www.geekmomprojects.com/led-matrix-shirt/ ➚

• https://makezine.com/projects/led-tank-top/ ➚

• https://www.circuitspecialists.com/blog/build-8x8-led-matrix/ ➚

Pressure Sensing Matrix and its code was pretty easy to understand, and straightforward as it can be directly taken from Kobakant’s resources ➚. The second prototype I made was a quick 3x3 pressure sensor with Velostat and copper tape to test out with the LED Matrix.


building the pressure sensor matrix

Some other helpful resources I came across are:

• https://www.kobakant.at/DIY/?p=7639 ➚

• https://www.hackster.io/Maurin/etextile-matrix-sensor-9d8843 ➚

• https://www.kobakant.at/DIY/?p=3363 ➚

• https://www.kobakant.at/DIY/?p=7943 ➚

As easy as I thought it would be, to map the incoming values from Sensor matrix onto the LED matrix, coding it was the most challenging part. (I still haven’t figured out the appropriate code for the exact effect I desired.) The smart people at Kobakant built the matrix and the code so that we only need one set of analog pins, and the values of intersecting points are stored by turning the other set of digital pins off sequentially, and recording the values in an array. However, the same was difficult to do while applying analogWrite() for LED matrix, since LED’s are diodes and the intersecting points are not just rows and columns, but also anodes and cathodes.

For the third prototype, which basically combines both the Matrices, after many trials and errors with the code, the following result was achieved, where the LED Matrix reads the position and values from the sensor, and turns on accordingly. (The LED’s also dim down or brighten up based on the pressure applied.)



Construction of the soft circuit
The fourth prototype, was to test how the layers planned and grid align, how is the experience of stitching with a sheer open-weave linen fabric, and how well do matrices work as soft circuit. And boy, was it an eye-opening experience!

The sewn circuit


LED’s are working, and the 5x5 matrix is supported by Teensy.

BUT!


The final outcome is glitchy, to say the least!

Quick reflections on this fourth Prototype:

• Sewing on an open-weave linen is not a great idea, perhaps I can try something like an organza which is sheer, but not loosely woven. I am not a fan of interlinings and fusings, although they might work as well.

• Sewing with Teensy’s tiny pins was a pain. I also need to think of a way so that Teensy can be detachable, and not have a new Teensy sewn on to every circuit I build.


The Mess around Teensy’s pins that need to be dealt in a better manner

Maybe try connector rings for clean and secure connections, and can also make Teensy detachable

• The connections are very iffy on soft circuits, and with matrices as these, it is really difficult to debug the hardware issues.

Construction of the final form

Working up with the layers. Teensy rings giving a cleaner connection.


The blurred layers of technology!


Finishing up with hemming the top layer.


Leaving pockets to access the battery and Teensy


The LEDs are working


still glitching


testing on a soft surface


Works well when using digitalWrite() (for rowsLED with value HIGH), instead of analogWrite()


Can you see how it thinks?
Do you want to touch it?
How will it feel?
How will you feel if you know how it feels?

Areas of improvement

• Still need to figure out a way to map analog values without glitching.

• Try building circuit with other sheer materials.

• The Matrix has a lot of potential to show reactions to touch! Another prototype planned is memory of touch, where the fabric remembers where and how it was touched and can recreate it after a certain duration.

• Can this work better if connections are soldered?

• Can this work better if layers are reduced?

• This can have potential to applications other than LEDs. Such as Behnaz Farahi’s Caress of the Gaze ➚. Shape Memory Alloys can also be an interesting medium to see the fabric react to touch.