12. Skin Electronics¶

Introduction¶

Skin Electronics Week is an exploratory space between the body and technology, where the skin transforms from a living surface into a sensitive, interactive interface. During this week, we delve into understanding wearable electronics on the skin, flexible materials, and how sensors and circuitry can be integrated with silicone and soft materials in a way that respects the body's movement and function. The week focuses on hands-on experimentation and design thinking to create applications that touch upon health, body expression, and art, while prioritizing comfort, safety, and sustainability.

Research¶

Skin electronics, or skin-integrated electronics, refers to a class of technologies designed to come into direct contact with the skin and move seamlessly with it, making the skin itself an interactive interface between humans and digital systems. This field combines electronic engineering, materials science, design, and medicine, opening new horizons for human-technology interaction.

The Concept of Skin Electronics Skin electronics relies on thin, flexible, and stretchable electronic circuits, typically manufactured using materials such as flexible silicone (Ecoflex, PDMS), conductive inks, and ultrathin metals. The primary goal is to mimic the skin's properties in terms of flexibility, lightness, and adaptability to movement without causing discomfort or harm to the user.

Materials and Technologies Used

Common materials include:

Flexible silicone as a substrate

Biosensors (heart rate, temperature, perspiration, motion)

Thin wires or printed conductors

Manufacturing technologies such as 3D printing, conductive ink printing, and soft lithography

Stretchability, secure skin adhesion, and electrical insulation are among the most significant technical challenges in this field.

Applications Skin electronics applications are diverse and include:

Health and Medicine: Continuous, non-invasive monitoring of vital signs

Sports and Fitness: Tracking physical performance and stress

Art and Design: As a new expressive medium that integrates the body with technology

Interaction and Interfaces: Controlling devices through skin touch or movement

Challenges and Ethical Dimensions

Despite its great potential, Skin Electronics faces challenges such as:

Long-term comfort and skin safety

Material lifespan and reusability

Privacy and protection of bodily data

Therefore, this field requires a balance between technological innovation and ethical responsibility.

In conclusion, skin electronics represent a radical shift in our relationship with technology, where devices are no longer separate from the body but rather an integral part of it. With the development of smart materials and ergonomically sensitive design, this field is expected to play a pivotal role in the future of health, fashion, and human interaction.

Articles¶

On-Skin Epidermal Electronics for Next-Generation Health Management

Wearable bioelectronics fabricated in situ on skins

Toward a new generation of permeable skin electronics

Skin-Interfaced Electronics: A Promising and Intelligent Paradigm for Personalized Healthcare

References & Inspiration¶

Takao Someya

Takao Someya, the University of Tokyo professor, A pioneer in ultra-flexible electronics and e-skin in Japan.

First experiment¶

A matrix touch sensor is an electronic device used to detect touch or interaction on a surface through a grid of sensitive points arranged in a matrix. This sensor allows for precise location of touch and sometimes even measurement of its intensity, making it suitable for interactive applications such as touchscreens, control interfaces, educational projects, and smart systems that rely on direct user interaction.

Building the Matrix with Copper Tape Steps¶

I took the following picture at the end of the experiment put we can see the taraces connected to the pins and the 100K ohm resistors also.

To experiment the sensor I used Arduino Uno and the next code from Naim-Ali page

#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);
}

To see the sensor Data visualized It was the first time to use Processing

Processing is an open-source programming language and software designed for digital art, interactive design, and creative coding. It's widely used to connect programming with visual design and to interact with sensors and data from microcontrollers like Arduino.

In simple terms:

Processing helps you transform data into graphics, animations, and visual interactions on a screen.

What does Processing do?

It draws shapes, lines, colors, and animations.

It receives direct data from sensors (such as touch or pressure sensors).

It handles interactive inputs (mouse, keyboard, camera).

It connects the physical world (hardware) with the digital interface (software).

Why use it with Arduino?

Arduino reads values from sensors.

Processing receives these values via serial.

Then it displays them visually (such as touch points, a pressure map, or direct interaction).

User examples:

Displaying touch locations in a Matrix Touch Sensor on the screen.

Heatmap drawing of pressure distribution.

Interactive art projects and exhibitions.

Visualization of sensory data.

After downloading the software and for my experiment I used the same code of Naim-Ali

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
      }
    }
  }
}

Second experiment¶

A pulse sensor is a biometric sensor used to measure heart rate in real time. It works by reading minute changes in blood flow within blood vessels with each heartbeat. It is widely used in wearables, motion-assisted interaction, and tech art projects because it is small and easy to integrate with microcontrollers like Arduino.

Its mechanism is based on the principle of light reflection. The sensor contains an LED that is illuminated on the skin (usually a finger or earlobe). With each heartbeat, blood flow increases, and the LED absorbs light differently. A photoelectric sensor detects these changes and converts them into an electrical signal representing the pulse. This signal is then processed by software to calculate the heart rate (BPM), which can be used to control visual or auditory interactions, such as changing colors or lighting.

After I downloaded the pulse sensor on arduino from library manager I tried the sensor alone for the first time just by connect it to the arduino uno.

My next step os to connect an LED to the sensor so I can see visualized result using a breadboard circuit.

I used this code for the experimenting

#define USE_ARDUINO_INTERRUPTS true
#include <PulseSensorPlayground.h>

const int PulseWire = A0;
const int LED_PIN = 13;
int Threshold = 600;

PulseSensorPlayground pulseSensor;

void setup() {
  Serial.begin(9600);

  pinMode(LED_PIN, OUTPUT);

  pulseSensor.analogInput(PulseWire);
  pulseSensor.setThreshold(Threshold);
  pulseSensor.blinkOnPulse(LED_PIN);

  pulseSensor.begin();
}

void loop() {
  if (pulseSensor.sawStartOfBeat()) {
    Serial.print("BPM: ");
    Serial.println(pulseSensor.getBeatsPerMinute());
  }
}

HeartSpectrum Headpiece¶

I have always been fascinated by the headpieces that women of ancient civilizations used to adorn themselves with.

The following pictures are taken from Tv serials Like turkish serial muhteşem yüzyıl you can find lots pictures for the fashion and accessories of the serial on pinterest

So for this week assignment I decided to use the heartpulse sensor and make HeartSpectrum Headpiece which is blinks in different colors depending on the heart beat.

for this design I used the following materials

The first step was to try one of the circuit units on the arduino, in the following video we can se the first unit of the circuit which consist of flora neopixel and wires: wire for the 5v, wire for the GND and the third for the the arduino digital pin. and the pulse sensor also connected to the arduino, GND, VIN, analoug A0.

To make the head piece I repeat this unit 3 times.

I started preparing the design with covering all the jumper wires that I needed with copper tape, then I added the beads to the wires that I want using the copper wire.

Then I started to collect the wires and the Leds to make the circuit. In the next vedio we can see the first experiment of the headpiece.

After I checked that the sensor is working, I complete connwcting the design pieces and adding the tulle flowers.

For arduino I used the following code to get the colourful effect while heart beat blinking, it depends on the heart beat, every range of heartbeats has different colors.

#define USE_ARDUINO_INTERRUPTS true

#include <PulseSensorPlayground.h>
#include <Adafruit_NeoPixel.h>

// ===== Pulse Sensor =====
#define PULSE_PIN A0
int Threshold = 600;   // 

PulseSensorPlayground pulseSensor;

// ===== NeoPixels (FLORA) =====
#define LED_PIN 6          // 
#define NUM_LEDS 3        // 

Adafruit_NeoPixel pixels(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  Serial.begin(9600);

  // Pulse Sensor setup
  pulseSensor.analogInput(PULSE_PIN);
  pulseSensor.setThreshold(Threshold);
  pulseSensor.begin();

  // NeoPixel setup
  pixels.begin();
  pixels.clear();
  pixels.show();
}

void loop() {

  // 
  if (pulseSensor.sawStartOfBeat()) {

    int bpm = pulseSensor.getBeatsPerMinute();
    Serial.print("BPM: ");
    Serial.println(bpm);

    uint32_t color;

    //
    if (bpm < 60) {
      color = pixels.Color(0, 0, 150);      // 
    }
    else if (bpm < 90) {
      color = pixels.Color(150, 150, 150);  // 
    }
    else {
      color = pixels.Color(150, 0, 0);      // 
    }

    // 
    for (int i = 0; i < NUM_LEDS; i++) {
      pixels.setPixelColor(i, color);
    }
    pixels.show();

    delay(60);   // 

    // 
    pixels.clear();
    pixels.show();
  }
}