12. Skin Electronics¶
Introduction and Inspiration¶
Overview of the Week’s Goal and Learning Objectives¶
The Skin Electronics week focused on integrating electronics with the human body using flexible, skin-adhering circuits. The goal was to explore conductive materials, capacitive sensing, and wearable interfaces that respond to touch. My experiments included DIY conductive inks, a matrix-based touch sensor, and a capacitive tattoo inspired by MIT’s DuoSkin. These projects helped me understand how electronic circuits can be embedded onto the skin for interactive applications.
Skin electronics involve ultra-thin, flexible circuits which can be applied to the skin for:
- Wearable computing – Interactive interfaces directly on the skin.
- Biomedical monitoring – Non-invasive health tracking and biofeedback.
- Interactive fashion and art – Wearables that respond to touch and motion.
- Augmented reality interfaces – On-skin controllers for digital systems.
By using materials like copper tape, conductive ink, and flexible substrates, these systems provide seamless interaction with digital environments.
Inspiration: DuoSkin, Henna Tattoos, and Other Interfaces¶
MIT’s DuoSkin¶
A major inspiration for this week was MIT’s DuoSkin, which uses gold leaf-based temporary tattoos as capacitive touch interfaces. These tattoos function as:
- Input devices – Acting as touch-sensitive buttons.
- Visual displays – Changing color based on temperature.
- Wireless communication tools – Using NFC technology.
Henna Tattoos as an Inspiration¶
Another inspiration came from traditional henna tattoos, used for centuries in Middle Eastern, Indian, and African cultures as decorative body art. The ornate and intricate designs of henna inspired me to think about wearable electronics not only as functional circuits but also as aesthetic body embellishments.
By combining the visual appeal of henna with interactive electronics, I explored how wearable circuits can be both decorative and technologically functional.
Experimenting with Conductive Ink¶
Objective¶
The goal of this experiment was to explore different methods of creating DIY conductive ink using readily available materials. Conductive ink can be used to draw flexible circuits directly onto surfaces, making it useful for wearable electronics, interactive art, and rapid prototyping.
I tested two different methods:
1. Graphite Layer on Paper – Using a pencil to create a conductive path.
2. Acrylic Paint-Based Conductive Ink – Mixing acrylic paint with conductive additives like graphite powder and gold leaf to create a paintable circuit.
Materials & Ingredients
- Graphite pencil
- Acrylic paint
- Graphite powder
- Gold leaf
- Alligator clips
- LED
- Power source (Power Supply)
Method 1: Graphite Layer on Paper¶
Process¶
The first approach was a simple pencil-based conductive ink method:
1. I heavily shaded a section of paper with a graphite pencil to create a thick, dark layer.
2. Using alligator clips, I connected both ends of the graphite path to test its conductivity.
3. I used this setup to bridge the gap in a circuit, attempting to power an LED.
Results & Observations¶
✅ Worked well for short distances – The LED lit up when the clips were placed close together, the power supply was set to supply 9V.
❌ High resistance over long distances – The LED dimmed or failed when the connection was stretched.
❌ Fragility – The graphite layer could easily be erased or worn away with handling.
This method confirmed the conductivity of graphite, but its high resistance and fragility made it unsuitable for practical applications.
Method 2: Acrylic Paint-Based Conductive Ink¶
Process¶
I attempted to create a more durable and versatile conductive ink by mixing:
- Acrylic paint (binder)
- Graphite powder (conductive filler)
- Gold leaf (to enhance conductivity)
The mixture was stirred thoroughly to distribute the conductive particles evenly. Once mixed, I applied it to a flat surface and allowed it to dry.
Results & Observations¶
✅ Formed a stable paint layer – More durable than graphite on paper.
❌ Limited conductivity – The paint showed weak electrical properties and couldn’t reliably power an LED.
❌ Uneven distribution of conductive particles – Some areas were more conductive than others.
Although this paint had some potential, it was not conductive enough for use in circuits. Future improvements could involve:
- Increasing the graphite-to-paint ratio to improve conductivity.
- Experimenting with alternative binders that don’t insulate the conductive particles.
- Using silver or carbon-based materials instead of gold leaf.
Conclusion¶
Both experiments provided valuable insights into DIY conductive ink creation. While the graphite layer on paper was conductive, it was too fragile for practical use. The acrylic-based ink was more durable but lacked sufficient conductivity. These tests highlight the importance of particle distribution and binder selection in conductive ink formulations.
In future iterations, I will experiment with more concentrated graphite suspensions, carbon-based inks, and silver nanoparticle inks to enhance conductivity while maintaining flexibility.
Creating a Matrix Touch Sensor¶
Concept¶
A matrix touch sensor works by creating a grid of conductive traces where each intersection acts as a potential sensor point. When a conductive or resistive material (such as velostat) is placed between the two layers, pressing at any point changes the resistance, allowing the system to detect pressure-sensitive touch. This type of setup is often used in pressure-sensitive keyboards, touchpads, and interactive textiles.
Design & Fabrication¶
Building the Matrix with Copper Tape¶
To create a simple 6×7 matrix touch sensor, I used copper tape to form the conductive grid and velostat as the resistive sensing layer.
Steps:¶
- Cutting the Copper Tape: I manually cut thin strips of copper tape using scissors.
- Creating the Two Layers:
- I took two square pieces of paper and applied parallel copper tape strips on each.
- One square had vertical strips, while the other had horizontal strips.
- Assembling the Layers:
- I placed a square of velostat between the two layers to create a pressure-sensitive interface.
- I rotated the top layer 90 degrees, ensuring that the copper tape strips faced each other but did not touch directly.
- Final Assembly:
- I secured the layers together, ensuring they remained aligned.
Electronics & Wiring¶
To interface the touch matrix with an Arduino, I used alligator clips to connect:
- Each row of the vertical copper strips to separate analog input pins.
- Each column of the horizontal copper strips to digital output pins.
This setup allows the Arduino to scan the grid by activating one column at a time and reading the values from the rows.
Arduino Code¶
The Arduino code scans the matrix by setting each column LOW one at a time while reading the analog values from the rows. The analog readings indicate how much pressure is applied at each intersection.
#define numRows 6
#define numCols 7
#define sensorPoints numRows*numCols
int rows[] = {A0, A1, A2, A3, A4, A5};
int cols[] = {11, 10, 9, 8, 7, 6, 5};
int incomingValues[sensorPoints] = {};
void setup() {
// Set all rows and columns to INPUT (high impedance):
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);
}
void loop() {
for (int colCount = 0; colCount < numCols; colCount++) {
pinMode(cols[colCount], OUTPUT); // set as OUTPUT
digitalWrite(cols[colCount], LOW); // set LOW
for (int rowCount = 0; rowCount < numRows; rowCount++) {
incomingValues[colCount * numRows + rowCount] = analogRead(rows[rowCount]); // read INPUT
}
pinMode(cols[colCount], INPUT); // set back to INPUT!
}
// Print the incoming values of the grid:
for (int i = 0; i < sensorPoints; i++) {
Serial.print(incomingValues[i]);
if (i < sensorPoints - 1) Serial.print("\t");
}
Serial.println();
delay(10);
}
Processing Visualization¶
To visualize the sensor data, I wrote a Processing script that:
- Reads the serial data from the Arduino.
- Maps the sensor values to grayscale intensity.
- Displays a grid of rectangles, where darker colors represent higher pressure and lighter colors indicate less pressure.
Processing is a software used for creative coding.
import processing.serial.*;
Serial myPort; // The serial port
int maxNumberOfSensors = 42; // Adjusted for 6x7
float[] sensorValue = new float[maxNumberOfSensors]; // global variable for storing mapped sensor values
int rectSize = 0;
int rectY;
void setup() {
size(600, 600); // Set up the window to whatever size you want
rectSize = width / 7; // Adjust based on the number of columns (7)
println(Serial.list()); // List all the available serial ports
// Use the correct port name for your Arduino
String portName = "COM29"; // Manually set the port name to COM29
myPort = new Serial(this, portName, 9600);
myPort.clear();
myPort.bufferUntil('\n'); // Corrected the quote character
background(255); // Set initial background
smooth(); // Turn on antialiasing
rectMode(CORNER);
}
void draw() {
rectY = 0; // Initialize rectY at the beginning of draw
for (int i = 0; i < maxNumberOfSensors; i++) {
fill(sensorValue[i]); // Set the color based on sensor value
rect(rectSize * (i % 7), rectY, rectSize, rectSize); // Draw the rectangle
if ((i + 1) % 7 == 0) {
rectY += rectSize; // Move to the next row after each 7th rectangle
}
}
}
void serialEvent(Serial myPort) {
String inString = myPort.readStringUntil('\n'); // Get the ASCII string
if (inString != null) { // If it's not empty
inString = trim(inString); // Trim off any whitespace
int incomingValues[] = int(split(inString, "\t")); // Convert to an array of ints
if (incomingValues.length <= maxNumberOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
// Map the incoming values (0 to 1023) to an appropriate gray-scale range (0-255):
sensorValue[i] = map(incomingValues[i], 400, 1023, 0, 255); // Further decrease sensitivity by adjusting the lower bound
sensorValue[i] = constrain(sensorValue[i], 0, 255); // Ensure values stay within the 0-255 range
}
}
}
}
Results & Findings¶
Another test using a different processing code:
✅ Successfully detected touch pressure – The system responded well to different levels of pressure.
✅ Basic interaction was possible – I could visualize the touch data in real-time.
❌ Sensitivity needed improvement – The readings were sometimes noisy.
❌ Alignment challenges – Small shifts in the layers caused inconsistencies in readings.
Future Improvements¶
- Use laser-cut copper traces for better alignment.
- Experiment with different resistive materials to improve sensitivity.
- Implement software filtering to reduce noise in sensor readings.
This simple matrix touch sensor demonstrated the potential of using soft and flexible materials for interactive electronics, paving the way for future improvements and applications in wearable interfaces.
Skin Tattoo – Inspired by DuoSkin¶
Concept & Inspiration¶
This project was inspired by MIT’s DuoSkin, which demonstrated how gold leaf-based tattoos could function as interactive, capacitive touch interfaces. The idea behind this project was to recreate a skin-worn touch sensor using copper tape and capacitive sensing, enabling the skin tattoo to control a digital interface.
For the tattoo design, I drew inspiration from henna tattoos, which are traditionally used as decorative body art in Middle Eastern cultures. The vine and leaves motif mimics the organic flow of henna designs while also serving as separate capacitive touch points, making the tattoo both aesthetic and functional.
Design & Digital Fabrication¶
Creating the Design in Rhino¶
I designed the capacitive tattoo using Rhino, ensuring that:
- Each vine acts as an independent capacitive sensor.
- The layout is visually appealing, inspired by henna-style body art.
- The design remains easy to cut and transfer using copper tape.
Cutting the Tattoo with a Vinyl Cutter¶
To fabricate the tattoo, I used a Roland Vinyl Cutter to precisely cut the vine design from copper tape. This process required careful preparation in Inkscape to ensure the design was suitable for cutting.
Preparing the Design in Inkscape¶
To set up the design for cutting, I used Inkscape, an open-source vector graphics editor, following these steps:
- Importing the Design:
-
I imported the DXF file of my vine design into Inkscape.
-
Setting Up the Cutting Parameters:
- Ensured that all lines were set to hairline width.
-
Removed any fill color so that only the stroke would be cut.
-
Sending the Design to the Vinyl Cutter:
- Instead of exporting, I printed the design.
- Selected the Roland Vinyl Cutter as the printer.
- Adjusted the height of the cutting area to 2mm longer than my design to prevent the machine from unrolling the entire copper tape roll.
Setting Up the Roland Vinyl Cutter for Copper Tape¶
- Loading the Copper Tape:
-
I carefully placed the copper tape onto the cutting mat, ensuring it was flat and aligned properly.
-
Adjusting the Blade Length:
-
I set the blade length to approximately 0.2 - 0.3 mm to cut through the tape without tearing it.
-
Setting the Blade Angle:
-
The Roland Vinyl Cutter uses a 45-degree blade, which is optimal for intricate designs.
-
Performing a Test Cut:
- Before cutting the full design, I ran a small test cut to ensure the blade pressure was correctly adjusted.
- Checked that the copper tape was cleanly cut without damaging the backing paper.
Transferring the Tattoo to Skin¶
Once the design was successfully cut:
1. I removed the excess copper tape, leaving only the vine pattern on the backing.
2. Used painter’s tape to carefully transfer the delicate design onto the prepared skin.
3. Ensured proper adhesion by pressing firmly before slowly peeling away the painter’s tape.
This method ensured that the copper tape tattoo remained intact and adhered smoothly to the skin for capacitive touch interaction.
Electronics & Programming¶
Wiring and Connecting to Xiao SAMD21¶
The capacitive tattoo was connected to a Xiao SAMD21, which features built-in Qtouch capacitive sensing on certain pins. Each vine was assigned to a separate pin, allowing multiple touch interactions.
Arduino Code for Capacitive Sensing¶
The Arduino code reads capacitive touch inputs from each vine and sends corresponding signals to Processing for visualization. The program detects when a touch occurs and transmits "Touched" or "Untouched" states via serial communication.
Schematic
┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐
│ Pad 1 │ │ Pad 2 │ │ Pad 3 │ │ Pad 4 │
│ A1 (2) │ │ SCK (8) │ │ MOSI (9) │ │ A6 (4) │
└────┬──────┘ └────┬──────┘ └────┬──────┘ └────┬──────┘
│ │ │ │
│ │ │ │
|__________________|__________________|__________________|
│
┌─────┴─────┐
│ Xiao SAMD │
│ 21 │
└───────────┘
│
┌─────┴─────┐
│ Computer │
│ (USB) │
└───────────┘
#include "Adafruit_FreeTouch.h"
Adafruit_FreeTouch qt_1 = Adafruit_FreeTouch(A1, OVERSAMPLE_4, RESISTOR_50K, FREQ_MODE_NONE);
Adafruit_FreeTouch qt_2 = Adafruit_FreeTouch(SCK, OVERSAMPLE_4, RESISTOR_50K, FREQ_MODE_NONE);
Adafruit_FreeTouch qt_3 = Adafruit_FreeTouch(MOSI, OVERSAMPLE_4, RESISTOR_50K, FREQ_MODE_NONE);
Adafruit_FreeTouch qt_4 = Adafruit_FreeTouch(A6, OVERSAMPLE_4, RESISTOR_50K, FREQ_MODE_NONE);
void setup() {
Serial.begin(115200);
}
int qt_Threshold = 850;
void loop() {
int qt1 = 0;
int qt2 = 0;
int qt3 = 0;
int qt4 = 0;
if (! qt_1.begin())
Serial.println("Failed to begin qt");
if (! qt_2.begin())
Serial.println("Failed to begin qt");
if (! qt_3.begin())
Serial.println("Failed to begin qt");
if (! qt_4.begin())
Serial.println("Failed to begin qt");
qt1 = qt_1.measure();
if (qt1 >= qt_Threshold) {
Serial.println("Touched1");
delay (200);
}
else {
Serial.println("Untouched1");
delay (200);
}
qt2 = qt_2.measure();
if (qt2 >= qt_Threshold) {
Serial.println("Touched2");
delay (200);
}
else {
Serial.println("Untouched2");
delay (200);
}
qt3 = qt_3.measure();
if (qt3 >= qt_Threshold) {
Serial.println("Touched3");
delay (200);
}
else {
Serial.println("Untouched3");
delay (200);
}
qt4 = qt_4.measure();
if (qt4 >= qt_Threshold) {
Serial.println("Touched4");
delay (200);
}
else {
Serial.println("Untouched4");
delay (200);
}
}
Processing for Visualization¶
Introduction to Processing¶
Processing is a software used for creative coding, allowing for real-time visual representation of sensor inputs. In this project, Processing was used to display interactive patterns based on tattoo touches.
Code for Visual Interaction¶
The Processing code:
- Reads serial data from the Xiao SAMD21.
- Updates four different areas on the screen based on touch states.
- Changes line patterns dynamically depending on whether a sensor is touched.
import processing.serial.*;
Serial myPort;
boolean[] touchStates = {false, false, false, false}; // Track the state of each sensor
void setup() {
size(800, 800);
background(0);
stroke(255);
// Initialize serial communication
String portName = Serial.list()[0]; // Adjust index if needed
myPort = new Serial(this, "COM35", 115200);
}
void draw() {
background(0);
int areaWidth = width / 2;
int areaHeight = height / 2;
// Draw the four areas based on touchStates
for (int i = 0; i < 4; i++) {
int x = (i % 2) * areaWidth;
int y = (i / 2) * areaHeight;
if (touchStates[i]) {
// Draw diagonal lines when touched
for (int j = 0; j <= areaWidth; j += 20) {
line(x + j, y, x + areaWidth, y + j);
line(x, y + j, x + j, y + areaHeight);
}
} else {
// Draw horizontal lines when not touched
for (int j = 0; j <= areaHeight; j += 20) {
line(x, y + j, x + areaWidth, y + j);
}
}
}
}
void serialEvent(Serial myPort) {
// Read serial input
String input = myPort.readStringUntil('\n');
if (input != null) {
input = input.trim();
// Update touchStates based on Arduino input
if (input.equals("Touched1")) touchStates[0] = true;
else if (input.equals("Untouched1")) touchStates[0] = false;
if (input.equals("Touched2")) touchStates[1] = true;
else if (input.equals("Untouched2")) touchStates[1] = false;
if (input.equals("Touched3")) touchStates[2] = true;
else if (input.equals("Untouched3")) touchStates[2] = false;
if (input.equals("Touched4")) touchStates[3] = true;
else if (input.equals("Untouched4")) touchStates[3] = false;
}
}
Application & Final Testing¶
Preparing the Skin¶
To ensure proper adhesion and insulation:
1. Wrapped the arm with seran wrap to prevent direct contact between copper tape and skin.
2. Carefully transferred the copper tape vines onto the arm.
Applying the Tattoo¶
- Each vine was connected to a separate pin on the Xiao SAMD21.
- After ensuring firm placement, the setup was ready for testing.
Final Testing & Interaction¶
- Ran the Arduino and Processing scripts.
- Successfully used the tattoo to interact with the Processing visuals.
- Observed different line patterns reacting based on which vine was touched.
Results & Improvements¶
✅ Successfully detected touch interactions.
✅ Processing visuals responded dynamically to touch.
❌ Copper tape adhesion was delicate – could improve by using temporary tattoo transfer paper.
❌ Sensitivity varied between vines – needed better calibration of threshold values in code.
Future Improvements¶
- Experiment with different conductive materials (e.g., silver ink, conductive polymer coatings).
- Improve tattoo adhesion for longer wearability.
- Expand interaction capabilities by integrating wireless communication (Bluetooth/NFC).
This project successfully demonstrated how skin-worn electronics can serve as interactive touch interfaces, blending technology with wearable aesthetics.