You can either use a pre-made touch matrix, like Loomia’s Mega Pressure Matrix (Figure B),
or make your own. Loomia makes a variety of amazing soft surface interfaces for prototyping. Their touch matrix panel is made of a sandwich of materials similar to what we will make here, but prefabricated and very reliable. The back of the panel also has a super handy adhesive coating to mount onto anything. And it’s got big connection pads for easy prototyping with alligator clips, with matching through-hole pads you can solder permanently when you’re ready (Figure C).

There are a series of other cool Loomia tools, like connectors, buttons, and even a heating panel (loomia.com/shop), but that’s for another article.
If you’re making your own matrix, first you’ll have to design your grid. An easy way to start is a regular grid with about 2″ spacing between rows and columns. Like most DIY electronics, especially textiles, there’s always the temptation to go small for the first try, but giving yourself some space will make the process easier.

Fig D

Fig E

Fig F

Fig G

Lay out the rows on one piece of material and the columns on another. Make sure they are straight and overlap properly if you place them on top of each other. It’s helpful to make a template with a marker first, and lay your traces on top (Figure D). Let’s start with a 3-row by 3-column piece, making 9 intersections.
Make sure the rows and columns go to the edge of your material on at least one side. Place a piece of velostat (Figure E) fully separating both grids (Figure F) and then sew it together with nonconductive thread into a delicious matrix sandwich. Rows and columns should never touch.
Attach an alligator clip to one end of each row and column. Connect the opposite clip to a jumper wire that you’ll connect to your Arduino. If you’re using a Loomia matrix, you can cover the through-hole pads with tape (or snip them off) and attach 6 alligator clips (Figure G).

Figure H

Figure I

To wire the circuit, you must connect each row and column correctly. We’ll make all the rows Analog, and all the columns Digital. I’ve used an Adafruit Flora because it’s made to attach alligator clips, and it’s round which is great for soft circuits (Figure ). But this concept will work with any similar microcontroller; just check your pinout diagram to find digital and analog pins (Figure ).

You can find the full, commented Arduino code at on Github. I’ve adapted and modified this code from Kobakant’s original resistive touch concept. It’s a bit hard to parse, so let’s break it down.

First, we will initialize variables we’re going to use and define the number of rows and columns so Arduino knows how to cycle through them.

define numRows 3

define numCols 3

Next we add the names of the pins to our rows[] and cols[] arrays — make sure to consult the pinout diagram! — and then create a two-dimensional array to hold the incoming variables so we can read the whole matrix at once:

int rows[] = {A10, A9, A7};
int cols[] = {3, 2, 0};
int incomingValues[numRows][numCols] = {};

In our setup function, we cycle through all the rows and set them to INPUT_PULLUP.

Note: If your controller doesn’t have an internal pullup resistor, you can add an external one by following these instructions. 

We will make all of the columns INPUT as well and start the serial monitor:

void setup() {
    for (int i = 0; i < numRows; i++) {
        pinMode(rows[i], INPUT_PULLUP);
    }
    for (int i = 0; i < numCols; i++) {
        pinMode(cols[i], INPUT);
    }
    Serial.begin(9600);
}

This is where the code gets a bit tricky. We’re going to fill every element in the second array by cycling through rows and then columns. We can see what column we’re in because we’ve set it to OUTPUT, and then cycle through all the rows inside of it. This way we don’t need as many pins, because we are isolating each row.

Upload this code (Figure J) to your Arduino and test it out! Have a look in the serial monitor to see the output.

At the end of the code are two functions that can help us debug. You’ll notice a grid of numbers in the serial monitor. The function printGrid cycles through all the rows and columns and prints them here as a number. When you push a button, or a copper tape intersection (Figure K), the value of that entire row will be lower, but the exact button location will also be clear as the lowest value.

In order to find the lowest value, we can use the findActiveButton(); function (Figure L) . This function cycles through all the incoming values and determines which is the lowest. If any of them are under 100, then it’s likely a button is being pressed. If you made your own touch matrix, it’s possible these numbers are different. You can use a calibration function to determine a baseline value (see Volume 86, pages 96–97), or just check manually what the values tend to be when something is pressed.
If you’re getting erratic readings, it’s possible that your resistive material isn’t fully separating your conductive rows and columns, or that a connection isn’t being made somewhere. Double-check your sewing and wiring.
To give your touch matrix a different feel, you can experiment with placement and even integrate the soft pressure sensors I shared in Volume 86, “Squish It! How to make a DIY pressure sensor.”