12. Skin Electronics

Skin Electronics

_{Temporary Tattoo Electronic Circuits by MC10}

Research

Skin electronics- what a strange idea. This whole week has felt so abstract. The concept of skin electronics is fascinating due to their size and what they can do for us.

It is a concept and an ongoing development of how we can wear circuits, sensors and bioelectronics directly on our body. They are built to send signals, to read different datas (for example pH level of your skin, heart rate etc), to track motion and even as interfaces! It is vital in the medical field, for patients who need to wear trackers for example for long periods of time. Due to their lightweight and small structures, it is easier to wear and feels more natural.

References & Inspiration

MC10 and John A Rogers

Probably the most fascinating part of my research was looking at the creations of John Rogers and his research team. The capabilities of the bioelectronics (or epidermal electronics), that attach to the skin like tattoos are tiny yet powerful. They can stretch in unison with your natural skin movement, they will monitor hydration, temperature and strain. It is believed that the data monitored by these tiny tattoos have a better potential of accurate results, as patients can wear them without discomfort in their natural environment for longer periods.

_{Sweat Sensor Skin Patch}

Another beautiful design is the microfuidic (sweat-sensing) skin patch that changes colour in accoradnce to different components in your sweat. It is small and stretchable, easy to wear. The data collected can be analyzed through an app in your smartphone.

_{Sweat Sensor Skin Patch}

Imagine if glucose levels can be detected without the use of needles and blood!

ECG Patch

dab ECG Holter Patch

Dab, designed by Adam Miklosi, is a small ECG Holter patch. It's specifically designed with user behaviour at its root, making sure that not only wearing it is comfortable and intuitive, but also more sustainable than the traditional ECG Holter monitors. It has built in blootooth and can connect direclty to an app in your smartphone.

Another similar skin electronic is the iRYTHM - The Zio Monitor, which has been FDA approved. It is easy to wear, designed to be worn all day everyday, it is waterproof and you can even connect it to an FDA cleared AI to give accurate diagnostics.

Zio ECG Monitor

DuoSkin Tattoo

The MIT Media Lab created these simple (yet not at all simple) temporary tattoos, that have three on-skin interfaces: sensing touch input, displaying output, and wireless communication.

Tools

• FabriXiao RP2040

• Arduino IDE

• Processing

• Copper Tape

• Alligators

• Velostat

• Usb - C type connection cable

• 3M Tegaderm Transparent Film Dressing

• NFC tag sticker (the smaller the better)

• Scissors

• Paper

• Flexible Aluminum wire with silicon cover

• Printable temporary tattoo paper

Process and workflow

As I mentioned at the start of my documentation, this week felt abstract and unlike any other week I had no idea where to even start. Even with all the research and lectures. However, I found my feet on the ground upon excercising the matrix circuit that Emma Pareschi demonstrated.

Pressure Matrix

_{Pressure Sensor schematics}

_{From Emma Pareschi Lecture}

I initially made an svg file to cut the copper tape with the Vinyl cutter Roland. It was my first time and I had to figure out the speed and that was interesting. I initially thought that we would need more pressure than cutting a vinyl sheet.

100 gf was the winner!

One of the things I love about electronics is how tidy and precise you have to be to make sure you don't need to rebuild it again.

Step 1

Align three of the cut-out copper tapes and stick them on one of the pieces of paper (6.5cm x 10cm), leaving 2cm empty from each side and spacing them 0.5cm apart. And do the same on the second piece of paper (4.5cm x10cm) leaving 1cm from the edges and spacing them 0.5cm apart. Place velostat in the middle.

Attach alligators from C1, C2, C3 to D9, D8, D7, then R1, R2, R3 to A0, A1, A2. Connect the Xiao RP2040 to the computer and Arduino IDE and run this code.

/*
The analog sensor is connected between pin A0 and pin 4
*/

int row0 = A0;  //first row pin
int row1 = A1;  //first row pin
int row2 = A2;  //first row pin

int col0 = 4;    //first column pin
int col1 = 5;    //first column pin
int col2 = 6;    //first column pin


int incomingValue0 = 0; //variable to save the sensor reading
int incomingValue1 = 0; //variable to save the sensor reading
int incomingValue2 = 0; //variable to save the sensor reading

int incomingValue3 = 0; //variable to save the sensor reading
int incomingValue4 = 0; //variable to save the sensor reading
int incomingValue5 = 0; //variable to save the sensor reading

int incomingValue6 = 0; //variable to save the sensor reading
int incomingValue7 = 0; //variable to save the sensor reading
int incomingValue8 = 0; //variable to save the sensor reading

void setup() {

  // set all rows to INPUT (high impedance):
    pinMode(row0, INPUT_PULLUP);
    pinMode(row1, INPUT_PULLUP);
    pinMode(row2, INPUT_PULLUP);

 //set the firt column as output
  pinMode(col0, OUTPUT);
  pinMode(col1, OUTPUT);
  pinMode(col2, OUTPUT);


  //open serial communication
  Serial.begin(9600);

}

void loop() {

  //set the col0 to low (GND)
  digitalWrite(col0, LOW);
  digitalWrite(col1, HIGH);
  digitalWrite(col2, HIGH);

  //read the three rows pins
    incomingValue0 = analogRead(row0);
    incomingValue1 = analogRead(row1);
    incomingValue2 = analogRead(row2);

  //set the col0 to low (GND)
  digitalWrite(col0, HIGH);
  digitalWrite(col1, LOW);
  digitalWrite(col2, HIGH);

    incomingValue3 = analogRead(row0);
    incomingValue4 = analogRead(row1);
    incomingValue5 = analogRead(row2);

  //set the col0 to low (GND)
  digitalWrite(col0, HIGH);
  digitalWrite(col1, HIGH);
  digitalWrite(col2, LOW);

    incomingValue6 = analogRead(row0);
    incomingValue7 = analogRead(row1);
    incomingValue8 = analogRead(row2);

  // Print the incoming values of the grid:

    Serial.print(incomingValue0);
    Serial.print("\t");
    Serial.print(incomingValue1);
    Serial.print("\t");
    Serial.print(incomingValue2);
    Serial.print("\t");
    Serial.print(incomingValue3);
    Serial.print("\t");
    Serial.print(incomingValue4);
    Serial.print("\t");
    Serial.print(incomingValue5);
    Serial.print("\t");
    Serial.print(incomingValue6);
    Serial.print("\t");
    Serial.print(incomingValue7);
    Serial.print("\t");
    Serial.println(incomingValue8);

delay(10); //wait millisecond
}

If you press on the pressure sensors and the numbers in the serial monitor lowers then it's working!

If you open the Serial Plotter then it should be somethings like this.

When you press on the sensors, the lines straighten and the harder you press the more straight they become- pressure sensor!

In the Processing app, run this code and make sure that your Xiao RP2040 is not busy on Arduino IDE.

/*
The sensors values are not calibrated.

*/

/*
Code based on Tom Igoe’s Serial Graphing Sketch
>> http://wiki.processing.org/w/Tom_Igoe_Interview
Reads X analog inputs and visualizes them by drawing a grid
using grayscale shading of each square to represent sensor value.
>> http://howtogetwhatyouwant.at/
*/

import processing.serial.*;

Serial myPort; // The serial port
int rows = 3;
int cols = 3;
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 rectSizeX = 0;
int rectSizeY = 0;
int rectY;


void setup () {
  size(1000, 1000); // set up the window to whatever size you want
  rectSizeX = width/rows;
  rectSizeY = height/cols;


  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.clear();
  myPort.bufferUntil('\n'); // don’t generate a serialEvent() until you get a newline (\n) byte
  background(255); // set inital background
  smooth(); // turn on antialiasing
  rectMode(CORNER);
}

void draw () {
  for (int i = 0; i < maxNumberOfSensors; i++) {
    fill(sensorValue[i]);
    rect(rectSizeX * (i%rows), rectY, rectSizeX, rectSizeY); //top left
    if((i+1) % rows == 0) {
      rectY += rectSizeX;
    }
  }
  rectY=0;
}


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], 000, 900, 0, 255); // stretch 5×5
        sensorValue[i] = constrain(incomingValues[i], 0, 255);
        //println(sensorValue[i]); // print value to see
        //println(incomingValues[i]);
      }
    }
  }
}

The harder you press, the darker it gets!

Wearing NFC Tag

An NFC (Near Field Communication) tag is the quickest and simplest way that I could be wearing electronics directly on my skin. Well, not exactly directly. I don't generally like to put things on my skin and a transparrent film dressing felt like the safest way. The smallest NFC sticker I could find was 2,5 cm. This could go on my arm, and using another layer of film dressing I could conceal it and protect it from being damaged too fast. I could also add a temporary tattoo on top, hiding it altogether.

Writing an NFC card is simple enough. All it takes is to download an application (NFC Tools) and in a few simple steps, you have yourself a readable NFC.

---

My printable temporary tattoo paper hasn't arrived yet, but I will update the tattoo with my own design once it does!

Photos by Svetlana Khachatryan

Wearable Pressure Sensor Matrix Grid

Skin electronics is especially important in the medical field, there is no doubt about that. However, it can serve so many purposes. What if it served women as protection against physical violence? What if wearing a pressure sensor directly onto your skin as an accessory or a temporary tattoo, could record, send signals and bring help?

Using the same Matrix grid, I decided to create pressure sensors that could be worn directly on the skin. To protect the skin from direct application of copper tape, I used 3M Tegaderm Transparent Film Dressing. A layer to protect the skin and a layer to protect the sensors.

_{Photos by Svetlana Khachatryan}

Testing with USB connection

I initially tested the grid using the USB port on the FabriXiao RP 2040, to make sure it works.

Once I was sure that it was working and my connections were good, I was ready to power it with battery. Unfortunately, we didn't have a 2 pin jet socket at the lab. What I did instead is I wired a small on/off switch to the battery and soldered the wires to the FabriXiao.

And voila!