Wander Watch – Fashion Technology Final Project

Wander Watch is a compass that lights up in the direction of your destination. You can use an app to enter where you’re going, and then put the phone away. This is part of a series of products I’m creating that help undo our overconnected lives.

This project was created for a course titled Expressive Interfaces: Introduction to Fashion Technology, and taught at ITP at NYU.

A slide deck can be found here.

Role: Ideation, concept development, physical design, fabrication, and coding.

Tools: Bluetooth LE, Cordova Phone Gap app, Don Coleman’s Bluetooth library, Javascript, Google Maps API, Tinkercad, 3D printers, Flora microcontroller, Flora Bluetooth LE module, Neopixel ring, webbing, velcro, thread and needle for strap.

IMG_2888

How It Works

The user opens the app, selects a destination, and sends it to the watch using Bluetooth LE. The watch lights up in the direction of the destination. The watch itself is 3D printed and encloses a stack of components.

 

 

Creative Process

Stage 1 – Concept development

  • Brainstormed what a wearable navigation piece might look like.
  • Illustrated the look and feel of the watch.

Artboard 1-100

Stage 2 – Research

 

Stage 3 – Code

  • Step by step, I assembled together my working code:
    • Confirm bluetooth connectivity using Flora microcontroller & Bluetooth module with Bluefruit app to confirm connectivity
    • Send commands to turn on and off specific Neopixel ring LEDs
    • Download and set up Don Coleman’s Cordova Phonegap app example
    • Use app to send commands to Neopixels
    • Insert Google Maps API Heading code into Bluetooth app.
    • Replace one map pin with phone’s actual location.

Stage 4 – Fabrication

  • Meanwhile, I developed and printed the physical design of the watch.
    • Research 3D printed watch designs online.
    • Create my own unique design in Tinkercad, including a tailored closing mechanism and opening for the strap.
    • Print test examples on the Ultimaker 3D printers at ITP.
    • Print a final prototype at NYU’s LaGuardia print shop on the Mojo printer.
    • Assemble strap by sewing velcro for an adjustable fit.

 

IMG_2851

IMG_2833

 

Next Steps

I hope in the future to add the GPS and magnetometer on the watch itself. In addition, I’d like to add three buttons on the side, so that a user can pre-program a few locations at home and leave their phone behind!

 

 

Collective Play: Final Project Playtesting

How might we create something intentional out of the unintentional? For this play test, Hadar and I asked people to leave behind something in their pocket and to leave behind a thought they want to get rid of.

 

IMG_2431

Thought Process

We discussed emotions and dynamics we wanted to create in people. We liked the idea of turning a random action into a purposeful action.

Playtesting

We set up a table underneath one of the TVs in the lounge area with paper and pens. The monitor above gave play instructions. Folks started to leave behind objects and thoughts.

IMG_2433

Expressive Interfaces: LED Circuit with a Switch

For this project I made use of snap buttons to create a switch to turn on and off and LED in the shape of another cat.

 

AdFSbp

How the piece is turned on, by connecting snap buttons.

Screen Shot 2018-03-29 at 3.54.50 PM

Illustrated diagram of the top piece’s circuit.

Screen Shot 2018-03-29 at 3.54.12 PM

Illustrated diagram of the back piece’s diagrams.

Tangible Interaction Workshop – Lighting Controller

IMG_1635

This is a wireless controller for the type of stage lights found in many performance venues.  The controller selects colors, changes the brightness, and turns the light on and off. The enclosure itself has a strong visual design that doubles as a control panel, suggesting to users how to interact with a circular soft potentiometer, a sensor not familiar to most people.

Tools: Soft potentiometer and rotary encoder, Arduino MKR1000 microcontroller, Tom Igoe’s sACNSource.h library, and vinyl adhesive sheets.

Demonstrating the controller’s color selection feature.

How It Works

The user’s interactions with the tangible sensors causes analog and digital signals to be sent to the Arduino microcontroller. Code saved on the microcontroller runs logic to determine what to do based on these signals, and then stores answers that are sent via wifi to lights using the DMX protocol (the standard language used to communicate with these standard lights found in performance and retail spaces).

IMG_1624

The circuitry inside.

Creative Process

Prototype 1 – Test Connectivity

  • Ran generic tests to guarantee connectivity to existing wifi and lights systems. Used simple code to connect microcontroller to private WiFi network and send DMX commands to stage lights.

Prototype 2 – Draft Pseudo Code & Test Features

  • Drafted code’s logic and structure to realize new designs for lighting controller.
  • Got help from Tom Igoe doing office hours to clarify understanding of rotary encoder’s behavior and how data is compiled to be sent as packets.
  • Obtained clean readings from sensors & tested new features by implementing one block of code at a time to isolate bugs and ensure smooth progress.

Final Prototype – Write Final Code & Fabricate

  • Controlled lights and fabricated enclosure.

 

Challenges & Next Time

I’d like to understand why my all of my controller’s features work when powered by my laptop, but only half work when powered by a LiPo battery (I used a 3.7v 2000mAh battery, which should be enough but I will have to find out). I also have some flow issues in the structure of my code, so that while a command exists to entirely shut off the lights, it’s not being activated. I hope to completely finish this controller and the MIDI music controller this spring.

Code

Designing Meaningful Interactions – Draft of Product Prototype

Here is a flow chart & drafted working prototype for my friend’s idea of a Studio Rental app. Looking forward to getting user feedback from people in the next week.

Link to prototype here, and a few screen shots below. I used Sketch to create the prototype, and Invision to create a shareable version online. I’ll work on connecting the hotspots.  https://invis.io/WYG3SWTBNRC#/282238030_Studio_Page 

I made the Flow Chart in Illustrator, using the graphics I created for the User Journey last week.

User Flow Chart

 

Screen Shot 2018-03-01 at 12.13.46 AMScreen Shot 2018-03-01 at 12.14.06 AMScreen Shot 2018-03-01 at 12.14.38 AM

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.

Contents

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.

Examples

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.

/*
12-23-2013
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).

Description:

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
pinMode(TOUCH_BUTTON_PIN, INPUT);

// Configure LED pin as output
pinMode(LED_PIN, 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:

https://learn.sparkfun.com/tutorials/at42qt101x-capacitive-touch-breakout-hookup-guide

References

Allaboutcircuit’s overview of capacitive touch:

https://www.allaboutcircuits.com/technical-articles/introduction-to-capacitive-touch-sensing/

Texas Instrument’s overview of capacitive touch:

http://www.ti.com/lit/an/snoa927/snoa927.pdf

EE Times’ overview of capacity touch:

https://www.eetimes.com/document.asp?doc_id=1279563

Sparkfun’s hook-up guide for the AT42QT101X:

https://learn.sparkfun.com/tutorials/at42qt101x-capacitive-touch-breakout-hookup-guide

Adafruit’s tutorial for their CAP1188 Breakout board:

https://learn.adafruit.com/adafruit-cap1188-breakout/downloads

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

https://www.bareconductive.com/shop/pi-cap/

Paul Stoffregen and Paul Badger’s CapacitiveSensor library:

https://github.com/PaulStoffregen/CapacitiveSensor

https://playground.arduino.cc/Main/CapacitiveSensor?from=Main.CapSense