Capacitive Touch Sensor Report: Breakout Boards

This report is part of a Sensor Library developed by Tom Igoe’s Tangible Interactions Workshop course at NYU’s ITP program.

Below you can read my report on capacitive touch and a few breakout boards.

You can view mine and my classmates’ reports on the course’s syllabus site over here.


This sensor report covers capacitive touch & compares a few breakout boards. I created a chart and went into more detail regarding a specific breakout board that is simple & reliable.

  • What is Capacitive Touch?
  • Pros – What is it good for?
  • Cons – Why buy a breakout board if you can DIY?
  • Comparison Chart
  • In-depth look at Sparkfun’s Breakout Board for Capacitive Touch using Microchip’s AT42QT101X (1010 or 1011)
  • Sample Code
  • References

animated (7)

One example of capacitive touch in action. This simple breakout board is covered below.

animated (2)

Behind a possible enclosure of acrylic. You can disconnect the LED if you like.

What is Capacitive Touch?
Capacitive Touch measures anything conductive or insulating, most commonly human touch. Capacitive Touch is great for both creative and useful applications because it works with many different materials, either in the form of the capacitive touch sensors themselves or paired with unique enclosures. This is because as mentioned, capacitive touch can measure anything that is either conductive or more insulating than air, even through an enclosure.

If your project has a lot of inputs, using a breakout board can help a lot. Here are a couple recent ITP projects that use cap touch. …Imagine if you wanted to have 20 cap touch buttons, moss controllers, or 20 sound lamps. A breakout board or two would come in handy.


Uses cap touch!

This interactive is by Brett Peterson, ITP alum, as part of the Senses exhibit at the American Museum of Natural History. Visitors can arrange puzzle pieces to teach a computer how to recognize imagery.

Capacitive touch sensors are used underneath the projected controls and table top surface, providing a very streamlined appearance.  As you can see, the sensors work most of the time, but not as regularly as arcade buttons might. 

American Museum of Natural History's interactive for machine learning.

Projector and web cam as part of interactive.

ITP Project page for Chelsea Pfohl’s Moss Touch. This uses capacitive sensors to control color and sound in a screen-based but 3D world.


ITP Project page for Yining Shi’s Atmospheric Sound Lamp. This uses cap touch to control light and sound of physical light sources.


How does it work?
Capacitive Touch works because the body’s water content is enough for a single finger or hand to change the electrical field surrounding two plates inside a capacitive sensor. The two plates can be thought of as antennae that senses changing electrodes.  The change in electrical field caused by a finger results in a reading that you can use in your code to trigger whatever event you’d like.

To clarify, the user can be near or far away from actual capacitive sensor itself. You can move the electrode, the pad that receives the user’s input, as far away as you like. It all depends on your materials and wiring.

Pros – What is it good for?
As for benefits, there are a few. Capacitive touch:

  • Allows your user to give inputs with something other than a typical button or slider — but still physically touch something (which is more intuitive than gesturing in the air).
  • Replaces mechanical components such as buttons or knobs which can wear and tear over time.
  • Can provide a more streamlined or unique appearance to your project’s enclosures & user inputs.

Cons – Why buy a breakout board if you can DIY?

Sure, for a one week assignment, you can DIY your electrode with copper, foil, velostat and conductive fabric, etc. And yes, you can use the Arduino Captouch library and put off buying a breakout board.

But for a larger project, you’ll want to spend a little money because your time is better spent figuring out the higher-level or trickier parts of your project, instead of debugging what you did by hand.  While yes, you can make your own quick electrodes (foil, copper, fruit),  by using a manufactured electrode and/or breakout board you can trust it will all work reliably. And using the Arduino Captouch library is good, but plan to only use an Arduino Uno, as the library is only written for that microcontroller (until it’s updated).


Comparison Chart of a Few Options

Name Product Image Price Inputs Chip & Maker Set Up Why You Might Want To Use It
Sparkfun’s Breakout Board AT42Qt101X $5.95 1 digital input AT42Qt101X by Microchip Microcontroller with GPIO (just input and output pins) Peace of mind. The board will reliably get cap touch readings.Built-in Button. It’s ready to go with no extra fabricating by you.

Aesthetic reasons.You may want a flat, streamlined look for your control panel or enclosure.

Adafruit’sCAP1188 – 8-Key Capacitive Touch Sensor Breakout – I2C or SPI

(Similar to the Adafruit 12-Key Capacitive Touch Sensor Breakout – MPR121)

 CAP1188 - 8-Key Capacitive Touch Sensor Breakout $7.95 8 or over 40 digital inputs if you create separate addresses CAP1188 by Microchip Microcontroller with I2C or SPI Peace of mind. The board will reliably get cap touch readings.Provides a lot of inputs.

Visual feedback.Built-in LEDs give you feedback while debugging lots of inputs.

Bare Conductive’s Pi Cap $39.95 12 digital inputs MPR121 by ROHRS Raspberry Pi with Bare Conductive’s Libraries If you want to use a Raspberry Pi. Let users use capacitive touch to interact with the internet, video file, interlocking programs, or calculations, thanks to the Raspberry Pi.
Captouch Library for Arduino Also see this page. 13 digital inputs Only works with the Arduino Uno, until the library is updated. No waiting.If you have an Arduino Uno, you can start right away without a special breakout board.

In-depth Report:

Sparkfun’s Breakout Board for Capacitive Touch using Microchip’s AT42QT101X (1010 or 1011)

animated (7)

The board in action. No mechanical parts due to the magic of capacitive touch.

What is it?  What does it do well?

Sparkfun’s breakout board is a cap touch button in and of itself. You don’t have to build your own electrode/button, unless you want to. It works well as a replacement for a key press.

What is it bad at?
Sparkfun and the chip maker say it’s built for proximity sensor readings. However, this barely worked for me, even on its most sensitive mode. To a regular user, it’s actually harder to hover 1 cm above the pad (proximity) then actually press it (touch).

animated (5)

Not great at proximity readings.

But on a related note, the board’s readings can be switched from Fast Mode to Slow Mode. Although a pain, you can move the solder on the back of the chip from Fast Mode to Slow Mode. Slow Mode is helpful if you want to use less power by sending fewer frequencies to the electrode’s pad, but be sure to test that it’s still sensitive enough to get the readings you want.

What does it NOT do?
Measure how hard the user is pressing!

Tips to Avoid Debugging

  • If you wire several of them together, be sure to figure out how to sync their clocks together.
  • If you wire one or more into a larger circuits, don’t share power. This might give you strange readings. Add a voltage regulator so that this board is protected from changes in power.

But how does it REALLY work? 
The AT42QT101X chip reads the conductive area in order to detect “touches” by a user. It does this by sending high frequencies to the pad. This technology is called “digital burst mode charge transfer” or “spread spectrum charge transfer”. If a finger is pressed, the pad changes the shape of the pulses. When the chip detects these slight changes it raises the OUT line to HIGH indicating that a touch is present. The amount of time you can say it’s “on” depends on whether you’re using the 1010 or 1011 chips (with the 1010 turns off after 60 seconds of being “on”; the 1011 stays on as long as the user presses it).

What would you use it for? You might use it in things like:

  • Control panels
  • Lighting controls
  • Anywhere a mechanical switch or button may be found
  • Large installations
  • The makers say it’s also good for toys.

You might also find it solves your design needs, such as:

  • For aesthetic reasons, you might want to create a streamlined look for your user input button behavior by hiding these underneath material.
  • For physically large projects, you can have your user be far away from your microcontroller when giving inputs.
  • For peace of mind, you can isolate your inputs into this specialized board so they’re more likely to work consistently (over creating your own).

Enclosure Ideas – What works or not?
You probably want to cover it up as part of an ITP project. The makers say it should work with a piece of acrylic (⅛” or thinner), cardboard, stone, ceramic, and most kinds of wood. I tested as many of these as I could. Some worked, others didn’t.


animated (2) animated (8) animated (3)
Works – Acrylic. Works – Mat board Works – Metal by itself
animated (6) animated (1)
: ( Doesn’t work – Thin wood. : ( Doesn’t work – Cardboard, surprisingly.


What code can I use for the AT42QT101X?

Sparkfun’s Shawn Hymel provides sample code you can start with, see below. You can also find it as part of the entire hook-up guide here.

SparkFun Electronics 2013
Shawn Hymel

This code is public domain but you buy me a beer if you use this
and we meet someday (Beerware license).


This sketch shows how to use the SparkFun AT42QT101X Breakout
Board. If you touch the Capacitive Touch area on the breakout
board, the LED attached to the Arduino will light up (in addition
to the LED on the AT42QT101X breakout board).

Simply connect power and ground to the breakout board,
and the AT42QT101X handles all the capacitive touch functions.
By default, the board will light up the green LED when the pad
is touched. A wire may also be connected from OUT on the
breakout board to a digital input pin on an Arduino. This signal
is normally LOW but goes HIGH on a touch detection.

The “LED Enable” solder jumper may be de-soldered in order to
control the LED directly from the LED pin. This is useful if you
want to light up a button that the user needs to push.

Hardware connections:

Uno Pin AT42QT101X Board Function

+5V VDD Power supply
GND GND Ground
2 OUT Capacitive touch state output

// Constants
const int TOUCH_BUTTON_PIN = 2; // Input pin for touch state
const int LED_PIN = 13; // Pin number for LED

// Global Variables
int buttonState = 0; // Variable for reading button

void setup() {

// Configure button pin as input

// Configure LED pin as output


void loop() {

// Read the state of the capacitive touch board
buttonState = digitalRead(TOUCH_BUTTON_PIN);

// If a touch is detected, turn on the LED
if (buttonState == HIGH) {
digitalWrite(LED_PIN, HIGH);
} else {
digitalWrite(LED_PIN, LOW);

Here’s the link to the AT42QT101X hook-up guide from Sparkfun:


Allaboutcircuit’s overview of capacitive touch:

Texas Instrument’s overview of capacitive touch:

EE Times’ overview of capacity touch:

Sparkfun’s hook-up guide for the AT42QT101X:

Adafruit’s tutorial for their CAP1188 Breakout board:

Bare Conductive’s information and directions for their Pi Cap:

Paul Stoffregen and Paul Badger’s CapacitiveSensor library: