We live in a world where technology built with the intent to connect people actually isolates us in practice (e.g. search bubbles, etc.). As if not complex enough, rising inequality across socio economics, education, and many other dimensions further separates our experiences. Our goal is to find a way to connect people with each other through a truly universal and truly human experience. By universal we intend it to be 1) Accessible to all regardless of time, location, ableness, creed, and 2) the same for all who engage with it (regardless of gender, race, socio-economic status etc.)

There are many avenues where we might connect with strangers. Not all connections are equal. Some are more intimate, others are more fleeting and light. In our installation, we hope to create the opportunity for many equally thoughtful connections between strangers, through sharing the warmth of their hands. 



People who go the same place, share an experience and thereby define a community. Our installation aims to expand the definition of this community by allowing people to share an experience across distance (and time). 

Connection with others is important - research has proved that it leads to longer lives and lower rates of depression and anxiety. Taking this a step further, the act of sharing an experience is actually what brings people happiness. But even without statistical data, we as human beings can already feel and understand why we should care about connection. The feeling of warmth that comes from sharing an experience with others is the most powerful evidence. 


Inspiration and Context

We were drawn to precedent projects that have either similar technical or conceptual goals. This adafruit project looks at how we could monitor temperature in terms of heating and cooling. In our own project, we want to proactively manage varying degrees of warmth to share with the person interacting with the installation. 

In another project, the Cryoscope heats up or cools down a metal slab to reflect the outdoor temperature. Users can touch the metal slab at home and get a sense of what it feels like outside, before getting ready to leave the apartment. Since one of the core functions of our own project is to convey heat and coolness from an external source, we thought the use of a metal surface (specifically copper for us) will be great for conductivity. 

Similar to the Cryscope, the Breakfast studio's piece Points shows that it's possible to share curated, time-relevant data from a range of networks without using touch screens as a crutch. We are inspired to also deliver data from a network to people who are interacting with the installation without a touch screen. 

Touch of warmth - IoT Project(CMU - MIIPS'20)
Rahul Vignesh - https://youtu.be/E2PebQhr0V8


We first started with the goal of creating a shared connection between people in physically different places. The ideas generated among the team ranged from using a love lock on a bridge to sense another's presence elsewhere, to holding a poll that was warm from someone else's touch. 

Ultimately, the team was most intrigued by the idea of receiving and giving warmth as a way to build connections between two people. Warmth is not just a emotional state but also a physical, tactile experience. We decided we could realize the experience using thermoelectric cooler peltier, capacitive touch sensor, and copper plates. And the internet would enable us to facilitate the act of storing and sharing of warmth between people near and far. 

Knowing that the interaction is physically feasible, we then moved on to the next question for how to package the sensors for people interacting with our installation. Since our goal is to bridge connection between people, we started thinking about what physical objects represent barriers today. Objects such as doors, walls, and locks came to mind. We eventually decided on creating a wall for our sensors, since it is by function a divider of spaces, and is used historically and politically to deliberately create barriers between people. 

In making the deliberate design choice to build a wall, but use it as a means to connect people, we hope to inspire inclusion rather than isolation.

Conceptually, a challenge we encountered was defining the community for our installation. We wanted to be as inclusive as possible, but also not just leave it at "it is an experience for all". Even though the experience was for all and lives in a public space, the feeling of warmth should be personal. We decided in the end, we will define the community simply by the experience they share. 

 From the technical side, we encountered challenges with the touch sensors that were to be installed behind the wall. Initially, we chose to use a capacitive sensor for a more reliable outcome. However, in practice we found ourselves averaging a lot of readings using the code. In the end, we simplified our approach by using FSR sensors and mocking them behind copper plates with a push mechanism. This solution did result in the expected interaction. That said, moving forward we would like to ensure accurate readings every time without asking people to consistently apply a lot of pressure onto a particular section of the plate. Another challenge we encountered was that our peltiers had worked effectively without the plate. The added plate deduced the effect of the warmth. Therefore, moving forward we would also like to somehow intensify that effect as it is the main factor of our piece.  


Conceptual Design 

We want to collect and share as much warmth feedback as possible, so it is important to place the wall in a highly foot-trafficked place. The ideal context is a place like Times Square in New York City, or Grote Markt in Brussels. 

Anyone should feel comfortable approaching the wall, and participating in the installation. Visual cues such as the brick texture used by the wall will also be present on the ground, leading people to approach and engage with the installation. 

The visitor of the installation will place a hand on the copper plate labeled "Send Warmth!" on the wall. While the warmth of the visitor's palm is being record, a series of LED lights light up from above the copper plate, indicating that recording is in-progress. The LED lights will light up in the direction of the second copper plate (receiving end), where the visitor can feel the warmth of another's hand. The warmth will be present for 1 minute. While the copper plate is warmed, a neopixel above will show colors of the flag from which the warmth is from. 





Detail what you created. What methods or techniques did you use? What tools and technologies were involved? Document the outcome itself (code, circuit diagrams, photos, design files, 3d models, video demonstrations, etc. as required) and provide a short narrative. A bill of materials (sensors, input devices, actuators, and other components) should be provided. This documentation should be sufficiently rich to allow anyone to repeat / recreate it.

Physical prototype: We began with understanding the user experience we would like to deliver, and sketched out forms that would make it possible. We also took inspiration from wall structures and forms from history, like the Berlin wall in Germany. We identified spaces this installation would be placed in, and from there came up with a simplistic wall that would capture our concept in the most powerful manner. Next, we used an existing cupboard as the skeleton for a foam core wall. To help visualize a realistic texture, we stuck a textured brick wallpaper onto the foam core wall. On the other side of the wall, two copper plates are embedded to record and receive warmth. Behind the copper plates, we placed FSR sensors (for recording end) and peltiers (for receiving end). 

Code: We separated our code into two parts: The recording side and the receiving of the code. First, we coded the peltiers interaction, followed by the neopixel, and finished with the touch sensors. To realize a full interaction from the cloud side, we will need to incorporate a proportional integral derivative (PID) controller in our code. So that when someone records their warmth, it is stored in the cloud and randomly received by someone via the wall. The IPD allows for the set random temperature to equalize to the current tile temperature by a slow hit and trial method. 

Recording warmth
// Define the Pin the Temperature sensor is on
int tempPin = A0;
int ledPin1 = D2;
int ledPin2 = D3;
int ledPin3 = D4;
int ledPin4 = D5;
int fsrPin = A5;
int fsrReading = 0;
int ledBrightness = 0;
bool isTouched = false;
int fsrave = 0;
float fsweight = 0.9;

// float expave0 = 0.0;
// float expave1 = 0.0;
// float expave2 = 0.0;

// double weightcap = 0.99;

// int roundedexpave0 = 0;
// int roundedexpave1 = 0;
// int roundedexpave2 = 0;

// int roundedexpave = 0;

// Create a variable that will store the temperature value
double temperature = 0.0;
double tempRnd = 0.0;
double weight = 0.99;
double avetmp = 0.0;
int count = 0;
// bool istouched = true;

void setup()
  // Register a Particle variable here
  Particle.variable("force", &fsrReading, INT);
  Particle.publish( "ready to feel the warmth" );
//   pinMode(TouchPin0, INPUT);  
//   pinMode(TouchPin1, INPUT);  
//   pinMode(TouchPin2, INPUT);  
    //Initiate Touch Pin as Input Pin
//   Particle.variable("expave0", &roundedexpave0, INT);
//   Particle.variable("expave1", &roundedexpave1, INT);
//   Particle.variable("expave2", &roundedexpave2, INT);
//   Particle.variable("touchreading", &touchreading, INT);
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);
  pinMode(ledPin4, OUTPUT);

  // Connect the temperature sensor to A0 and configure it
  // to be an input
  pinMode(tempPin, INPUT);

void resetLEDs(){
    digitalWrite(ledPin1, LOW);
    digitalWrite(ledPin2, LOW);
    digitalWrite(ledPin3, LOW);
    digitalWrite(ledPin4, LOW);

void outputLEDs(int level){
    if (level > 10000){
        level = 10000;
    if (level < 1){
        level = 1;
    if (level >= 3500){
        digitalWrite(ledPin1, HIGH);
        digitalWrite(ledPin2, HIGH);
        digitalWrite(ledPin3, HIGH);
        digitalWrite(ledPin4, HIGH);
        if (level >= 2500){
            digitalWrite(ledPin1, HIGH);
            digitalWrite(ledPin2, HIGH);
            digitalWrite(ledPin3, HIGH);
            if (level >= 1800){
                digitalWrite(ledPin1, HIGH);
                digitalWrite(ledPin2, HIGH);
                if (level >= 10){
                    digitalWrite(ledPin1, HIGH);

void loop()
   fsrReading = analogRead(fsrPin);
   fsrave = fsweight * fsrave + (1 - fsweight) *fsrReading;
  //ledBrightness = map(fsrReading, 0, 4095, 0, 255);
//   analogWrite(ledPin, ledBrightness);
   if (fsrave > 2000){
      isTouched = true;
      count = 0;
   //count = 9000;
   //Particle.publish( "FSR Reding publish", String(fsrReading));
   if (isTouched == true){
      // Keep reading the sensor value so when we make an API
      // call to read its value, we have the latest one
      int reading = analogRead(tempPin);
      // The returned value from the device is going to be in the range from 0 to 4095
      // Calculate the voltage from the sensor reading
      double voltage = (reading * 3.3) / 4095.0;
      // Calculate the temperature and update our static variable
      temperature = (voltage - 0.5) * 100;
      avetmp = weight * avetmp + temperature * (1 - weight);
      tempRnd = round(avetmp * 100) / 100;
   //read the touch value and assign to touch variable
    // touch = analogRead(TouchPin1);
    // expave1 = weightcap * expave1 + (1 - weightcap) * touch;
    // roundedexpave1 = round(expave1);
    // touch = analogRead(TouchPin2);
    // expave2 = weightcap * expave2 + (1 - weightcap) * touch;
    // roundedexpave2 = round(expave2);
    // touch = analogRead(TouchPin0);
    // expave0 = weightcap * expave0 + (1 - weightcap) * touch;
    // roundedexpave0 = round(expave0);
    // roundedexpave = round((expave1 + expave2 + expave0) /3);
    // touchreading = map( roundedexpave, 0, 4095, 0, 255);
    // delay(1);
    //Publish the result
    //Particle.publish( "TouchDetected" );
    //Particle.publish( "TouchSensorReading", String( touchreading ));
// }
Tarika Jain (2019) Click to Expand
//Feeling the warmth side code//

// This #include statement was automatically added by the Particle IDE.
#include <neopixel.h>

int PeltierPin = D2;
int TouchPin = A3; 
int touch = 0;
int touchreading =0;
int count2 = -1;
int i = 0;

#define PIXEL_PIN D4
//define the pin neopixel is connected to
#define PIXEL_COUNT 7
//define the pixel count of the neopixel 
#define PIXEL_TYPE WS2812
//define neopixel type  
Adafruit_NeoPixel strip = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, PIXEL_TYPE);
//Define again that this is a adafruit neopixel 
//Adafruit_NeoPixel strip = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, PIXEL_TYPE);
int timeGreen = 1000 * 60 *1;
int timeFeel = 1000 * 60 *1;
float expave = 0;
float weight = 0.8;
int roundedexpave = 0;
//long timerStartedAt = -1 ;
//int timeToStart = 0; 

void setup() 
    Particle.publish( "ready to feel the warmth" );
    pinMode(TouchPin, INPUT);  
    //Initiate Touch Pin as Input Pin
    pinMode(PeltierPin, OUTPUT);
    //Initiate Peltier Pin as Output Pin
    Particle.variable("TouchDetect", &touch, INT);
    Particle.variable("count", &count2, INT);
    Particle.variable("i", &i, INT);

void UpdateNeo(){
    //i = level % 7;
    //i = i +1; 
    i = count2;
    //show red pixel
    uint32_t c = strip.Color(255, 0, 0);
    if (i <= 2){
        strip.setPixelColor(i, c);
    //show blue pixels
    c = strip.Color(0, 0, 255);
    if ((i >= 3) and (i <= 6)){
        //setBrightness funciton will slowly dim the LED strip
        strip.setPixelColor(i, c);
    //show white pixel
    c = strip.Color(255, 255, 255);
    if ( i >= 7){ 
        strip.setPixelColor(i, c);


void loop() 
    //read the touch value and assign to touch variable
    count2 = count2 + 1;
    //Particle.publish("count", String(count2));
    touch = analogRead(TouchPin); 
    //touchreading = map( touch, 0, 4095, 0, 255);
    if (touch > 3000){
        //Heat Peltier
        digitalWrite(PeltierPin, HIGH);
        //Update Neo with sequence
        //initialize the peltier now itself 
        if (count2 == 8){
           count2 = 0;
        //Reset count
        count2 = -1;
        //Turn off Neo
        digitalWrite(PeltierPin, LOW);
Click to Expand

Next Steps

What would you do if you took this project forward and why? What would you do differently? What would you need to consider if you took this idea forward and why?

With the feedback we got, there are some changes we would like to make on our prototype. To visually communicate the solidity of the wall, we will use real bricks in our next iteration. In terms of the warmth transferred through the copper plate, currently it is very subtle and mild. We would like to look at how we might increase the intensity of the warmth. Lastly, since this project is meant to be an international installation, it will also be necessary to consider how the warmth is receive in different environments. 



All references are directly linked in the text above. 

Share this Project


49713 Designing for the Internet of Things

· 16 members

A hands-on introductory course exploring the Internet of Things and connected product experiences.




December 5th, 2019