Skip to content

13. Skin Electronics


Continuing from my research from the soft robotic week I am still fascinated by the cross-section between electronics and living material.

I believe bioelectronics has a possibility to solve many of the sustainability problems in electronics.

Organic electronic materials possess a combination of both electronic and ionic/molecular conductivity, it is possible to transfer ionic (biological) to electronic signals. It is mindboggling to think about what will happen when we seamlessly will be able to integrate and code the electronic and biological world.

bioelectronic lab

So how can we integrate it into a body, maybe with tatooes?

The color-changing tattoos in development are also going to open the door to a new kind of dynamic body art. The tattoo colors can be changed by an electromagnetic signal.

In the future you could be able to “program” your tattoo’s design, depending on what environment you are in.

link Electronic tattoes could also be used as a interface between hard and soft robotics and actually let Humans Feel What Robots do or ofcourse the other way around

One of the problems with skin electronics is of course the battery that makes the electronics difficult to seamlessly integrate in your life. Scientists developed a smart second skin that gets all the power it needs from sweat. link link


So how could we use our body in our digital life,
what about if we could model in Rhino using our hands?
what would be the metaverse experience?
As the first baby step, I decided to create a pressure-sensitive matrix using this tutorial from kobakant which allows me to visualize (on screen) the touch of my body using the processing software.

A digital fidget toy.

I wanted to create a very clean strong sensor that would actually be practical to use on the skin so I decided to mold it in silicone instead of the plastic sheets that he was using.


First I made a rough mockup in paper with a 3x3 grid of conductive tape and eostan fabric.
Testing the mockup with the serial monitor and plotter.

The monitor gives an intuitive feeling of the analog input data (right) while the plotter (left) gives much more detail about the reading. The range for our ESP32 board is 4095-0, when you press the fabric the number should go down to 0


Seams all working fine, let’s move on to final sample.

final sample:

Mold laser cut from acrylic sheets

power: 100
speed: 0.50
PPI/HZ: 2000

Conductive Copper sticker cut with vinyl cutter
Resistor Eontex fabric
vinyl cutter

Soldering the connections.
it is actually not that easy its worth looking through this tutorial:

Pour a thin layer of silicone into the mold (ca 1mm)
Place the copper strips on a 2mm acrylic sheets (same size as your eontex fabric) place the “plug” in the mold on top of the silicone bottom layer with the copper facing down.
Fill up to the edge of the "moldplug" with another thin layer of silicone
Repeat the process to create the other side of the silicone mold
Remove your acrylic plug and place the eontex fabric in the empty space

paint a thin layer of silicone along the edges and close the sensor.
before gluing the two sides together final sample Step8
Wiring to the breadboard, use one 10 ohms resistor for every analog input Step7
Connect to Arduino board using serial plotter
Code here:

//Emma Pareschi- Dec 2020
//Modify example from Pressure Sensor Matrix Code
//parsing through a pressure sensor matrix grid by switching individual
//rows/columns to be HIGH, LOW or INPUT (high impedance) to detect
//location and pressure.

#define numRows 5
#define numCols 5
#define sensorPoints numRows*numCols

int rows[] = {A0, A1, A2, A3, A4};
int cols[] = {13, 12, 27, 33, 15};
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);

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
    }// end rowCount

    pinMode(cols[colCount], INPUT); // set back to INPUT!

  }// end colCount

  // Print the incoming values of the grid:
  for (int i = 0; i < sensorPoints; i++) {

    if (i < (sensorPoints - 1)) {
    //    Serial.println("");}

Connect to processing using this code:
Code based on Tom Igoe’s Serial Graphing Sketch
 Reads X analog inputs and visualizes them by drawing a grid
 using grayscale shading of each square to represent sensor value.

import processing.serial.*;

String myString = null;
String inString = null;
int lf = 10;    // Linefeed in ASCII

Serial myPort; // The serial port
int rows = 5;
int cols = 5;
int maxNumberOfSensors = rows*cols;
float[] sensorValue = new float[maxNumberOfSensors]; // global variable for storing mapped sensor values
float[] previousValue = new float[maxNumberOfSensors]; // array of previous values
int rectSize = 0;
int rectY;
void setup () {
  size(600, 600); // set up the window to whatever size you want
  rectSize = width/rows;
  println(Serial.list()); // List all the available serial ports
  String portName = Serial.list()[2]; // set the number of your serial port!
  myPort = new Serial(this, portName, 9600);
  myPort.bufferUntil('\n'); // don’t generate a serialEvent() until you get a newline (\n) byte
  background(255); // set inital background
  smooth(); // turn on antialiasing

void draw () {
  for (int i = 0; i < maxNumberOfSensors; i++) {
    rect(rectY, rectSize * (i%rows), rectSize, rectSize); //top left
    if ((i+1) % rows == 0) rectY += rectSize;

void serialEvent (Serial myPort) {
  inString = myPort.readStringUntil(lf); // 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 4095) to an appropriate gray-scale range (0-255):
        sensorValue[i] = map(incomingValues[i], 2000, 4095, 0, 255); // stretch 5×5
        sensorValue[i] = constrain(sensorValue[i], 0, 255); // stretch 5×5
        //println(sensorValue[i]); // print value to see

it works



The molding process that I was using was probably bit too complicated, it was hard to make it really clean and detailed. Kobakants original process might have been a better concept for fabricating by hand.


fabrication file here

Last update: 2023-04-11