13. Skin Electronics¶
Research¶
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
link
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
Assigment¶
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.
Process¶
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
test
Seams all working fine, let’s move on to final sample.
final sample:¶
Mold laser cut from acrylic sheets
setting
power: 100
speed: 0.50
PPI/HZ: 2000
Conductive Copper sticker cut with vinyl cutter
Resistor Eontex fabric
vinyl cutter
Step1
Soldering the connections.
it is actually not that easy its worth looking through this tutorial:
Step2
Pour a thin layer of silicone into the mold (ca 1mm)
Step3
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.
Step4
Fill up to the edge of the "moldplug" with another thin layer of silicone
Step5
Repeat the process to create the other side of the silicone mold
Step6
Remove your acrylic plug and place the eontex fabric in the empty space
Step7
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.
//>> https://www.kobakant.at/DIY/?p=7443
#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);
}
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
}// 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++) {
Serial.print(incomingValues[i]);
if (i < (sensorPoints - 1)) {
Serial.print("\t");
}
// Serial.println("");}
}
Serial.println();
delay(10);
}
Connect to processing using this code:
/*
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.*;
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("TEST");
println(Serial.list()); // List all the available serial ports
println("HELLO");
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(rectY, rectSize * (i%rows), rectSize, rectSize); //top left
if ((i+1) % rows == 0) rectY += rectSize;
}
rectY=0;
}
void serialEvent (Serial myPort) {
inString = myPort.readStringUntil(lf); // get the ASCII string
println(inString);
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
//println(incomingValues);
if (incomingValues.length <= maxNumberOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
//println(incomingValues[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
}
}
}
}
shematics
Conclusion:¶
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.
Download:¶
fabrication file here