A connected gym ecosystem that measures and uses workout data and biological parameters to optimize workout sessions and nutrient intake by supplying comprehensive performance feedback to the user.

0

Vision

The gym is a place frequented by many. It is associated with fitness, diet, nutrition, confidence, discipline and overall health. In the current scenario where almost all aspects of our life are 'smart' and connected, the concept of the gym as an ecosystem of connected devices is a logical next step. Almost all devices in this domain, both on the market and future concepts, are designed with the intention to better provide data regarding workouts and sports. Current devices tend to offer solutions designed to make exercise more convenient and resource efficient, such as the barbells that can change their weight through centrifugal force, magnets, or other methods. However, there is no efficient usage of the data to provide tangible improvements or effective recommendations to the users.  We aim to create and demonstrate a connected ecosystem for a gym in the year 2021 that not only converts this raw data to useful information for the user, but also uses this information to enrich their experience in a tangible way.

We found that gym users are interested in understanding their nutrition requirements and consuming food that most effectively supports their workouts to attain their fitness goals. An overwhelming amount of data on the matter is available online but users are unable to translate this data to their customized workouts. Guided by our findings and insights from primary and secondary research, this project focusses on deeper biological data, and the relationship between the food supply and the way your body is using it and aims to convert the existing gym ecosystem into the ecosystem in our vision.

Final report page 003.thumb  


Final report page 017.thumb  

0

Goal

To create extended ecosystem of connected devices that optimizes fitness performance outcomes through precise diet and exercise feedback.  

0

Design Process




We followed these steps to create our gym ecosystem:


1. Stakeholder Map : All the stakeholders who would be affected by this ecosystem were identified and positioned on the map. The gym user was identified as our primary stakeholder and the other stakeholders are placed relative to the user on the map based on their relevance and importance.




2. User Interviews : Gym users were interviewed to understand their routine, diet and exercise preferences and likes and dislikes with respect to the gym. Some of the quotes are as below:

“I track my workout sessions carefully every time” 


“I prefer to participate in group exercises with friends. Weights bore me”  


“Runkeeper is my best friend when it comes to fitness. I use it to track all my cardio workouts”  


“I go to the gym for weights only. I don’t find cardio useful”  


"I don't know how to supplement my workout with the correct diet"


 

3. SET Factors: Social factors, economic forces and technological trends for 2021 were identified and the most important and relevant ones were highlighted. These trends were considered in the design of our ecosystem.


Final report page 006.thumb   

4. Ideation and Concept Generation: Based on the insights we gained, the team brainstormed and decided to create an ecosystem based on real-time tracking of biological data and nutrient and consumption water intake. Image boards were created for inspiration.

5. Prototyping: Prototypes of the devices by created by the teams. Many iterations resulted in a refined concept. Next, the devices were connected with each other to test for optimal data exchange. Finally, the devices were connected to the website which shows real-time data of the workout.


0

The Concept

There are 3 main devices from our ecosystem used by the user in the gym. A sweatband embedded with a moisture sensor checks the hydration level of the user and reminds them to hydrate as they are busy working out and may not pay attention to their water intake. This data is sent to the cloud and also to the website. The other device is the flex band that detects muscle activity during the exercise and measures the number of reps, sets and also the calories burnt. The band can be moved on to any limb that is being exercised. A similar device would be the lat machine (which represents any weight machine in the gym). These devices transmit their data to the cloud, to the website and to the next device, the food dispenser. The food dispenser decides the amount of liquid soylent that is to be dispensed to the user after each workout based on their calorie count and  dehydration levels.

Final report page 015.thumb  

Img 20160302 184149491.thumb  

0

Device 1

Sweat Sensing Band

This device is used to give an important information regarding the hydration level of the users,and the liquid intake required by them.They function by taking the moisture (based on circuit resistance) exhausted by the user as input and accordingly evaluates them based on set thresholds. It finally communicates to the gym goer, if they are hydrated in sufficient amounts or de-hydrated,after which the required intake is prescribed.The output data is stored in the cloud for further processing by other devices,displayed on the OLED Screen and is also published on the website foe easy accessibility by the users.

Components Used:

1. Particle Photon

2. Moisture sensor 

3. Jumper wires (many)

4. OLED Display Screen

5. Power supply - 5V

Final report page 021.thumb  

Img 20160302 181551582.thumb  

0
Sweat Sensor Fritzing
Sweat smart circuit.thumb
0
Coding for Sweat Sensor
#include "Adafruit_GFX.h"

#include "Adafruit_SSD1306.h"

#define OLED_DC     D3
#define OLED_CS     D4
#define OLED_RESET  D5
#define NUMFLAKES 10
#define XPOS 0
#define YPOS 1
#define DELTAY 2
#define LOGO16_GLCD_HEIGHT 16
#define LOGO16_GLCD_WIDTH  16

Adafruit_SSD1306 display(OLED_DC, OLED_RESET, OLED_CS);


static const unsigned char logo16_glcd_bmp[] =

{ 0B00000000, 0B11000000,
  0B00000001, 0B11000000,
  0B00000001, 0B11000000,
  0B00000011, 0B11100000,
  0B11110011, 0B11100000,
  0B11111110, 0B11111000,
  0B01111110, 0B11111111,
  0B00110011, 0B10011111,
  0B00011111, 0B11111100,
  0B00001101, 0B01110000,
  0B00011011, 0B10100000,
  0B00111111, 0B11100000,
  0B00111111, 0B11110000,
  0B01111100, 0B11110000,
  0B01110000, 0B01110000,
  0B00000000, 0B00110000 };

#if (SSD1306_LCDHEIGHT != 64)
#error("Height incorrect, please fix Adafruit_SSD1306.h!");
#endif

int thresholdUp = 3500;
int thresholdDown = 250;
int sensorPin = A0;
int SweatData = 1;
int sensorValue;
bool userIsDehydrated = false;
void setup ()
{

  display.begin(SSD1306_SWITCHCAPVCC);
  display.clearDisplay();
  Particle.variable("Sweat Data", SweatData);

}
void loop ()
{
  sensorValue = analogRead(sensorPin);

  int SweatData = sensorValue;

  if (sensorValue >= thresholdUp)
  {
    display.clearDisplay();
    display.setTextSize(2);
    display.setTextColor(WHITE);
    display.setCursor(20,0);
    display.println("Hydrate Please!");
    display.display();
    /*userIsDehydrated = true;*/
    if(userIsDehydrated == true) {
      /*do nothing*/
      /*Warn again*/
    } else {
        
        userIsDehydrated = true;
    }

  }
  else
  {
    display.clearDisplay();
    display.setTextSize(1);
    display.setTextColor(WHITE);
    display.setCursor(20,0);
    display.println("All good! Keep it going!");
    display.display();

    userIsDehydrated = false;


  }
  delay(1000);

}
Click to Expand
0

Device 2 (A)

Muscle Sensor Tape

This device helps in measuring the muscle flexibility,particularly while using dumb bells and doing push ups. It takes the Pressure change as a parameter for each cycle of expansion and contraction of the muscles.Based on this change,the rep and calories expended by the user are logged on the website.

Components Used:

1. FSR (force sensitive resistor- SEN-09673 )

2. 10 Kilo Ohm resistor

3. Particle Photon

4. Connecting wires

5. 9V Battery Pack

Final report page 022.thumb  

Img 20160302 181631917.thumb  

Img 20160302 181638452.thumb  

0
Photon with FSR Sensor
I1.thumb
0
Coding for Flex Sensor
int fsrAnalogPin = 0; // FSR is connected to analog 0
int LEDpin = 11;      // connect Red LED to pin 11 (PWM pin)
int fsrReading;      // the analog reading from the FSR resistor divider
int LEDbrightness;
int i=0;
int calories=0;

void setup(void) {
  Serial.begin(9600);   // We'll send debugging information via the Serial monitor
  pinMode(LEDpin, OUTPUT);
  Particle.variable("fsr", fsrReading);
  Particle.variable("reps", i);
  Particle.variable("cal", calories);
}

void loop(void) {
  fsrReading = analogRead(fsrAnalogPin);
  //Serial.print("Analog reading, Reps = ");
  //Serial.println(fsrReading);
  //Serial.print(i);
  Serial.print(calories);

  if ( fsrReading > 1000)
  { i=i+1;
    calories= calories+2;
  delay(300);
  }

  // we'll need to change the range from the analog reading (0-1023) down to the range
  // used by analogWrite (0-255) with map!
  LEDbrightness = map(fsrReading, 0, 1023, 0, 255);
  // LED gets brighter the harder you press
  analogWrite(LEDpin, LEDbrightness);

  delay(100);

}
Click to Expand
0

Device 2 (B)


Lat machine sensor

This sensor is used in each of the LAT devices to monitor the user's exercise cycle.Each time,the user,for a particular weight,attached to the machine,the following parameters are measured:

1. The distance of the pull action,taken from the ultra-sonic sensor.

2.The number of times the action is performed using the break-beam sensor(it serves as the counter)

Based on these two values,with respect to a particular weight attached,the calories consumed by the user for the entire workout session is calculated.This data is then sent to Device 3 ,for providing the users with a proper diet supplement .


Components Used:

1. Break Beam sensor

2.Ultrasonic distance sensor

3. Particle Photon

4. Bread Board and Connecting wires

5. 9V Battery pack


Final report page 023.thumb  

Lat.thumb  

0
Break Beam Sensor Circuit
I3.thumb
0
Coding for LAT Machine
#include <stdio.h>
#include <string.h>
#include <math.h>​
int SENSORPIN = A4;
int sensorState = 0, lastState=0;
const int trigPin = 2;
const int echoPin = 4;
int rep=0;
int calories;
String data;

void setup() {
  // initialize serial communication:
  pinMode(SENSORPIN, INPUT);
  digitalWrite(SENSORPIN, HIGH);
  Serial.begin(9600);
}

void loop()
{
  // establish variables for duration of the ping,
  // and the distance result in inches and centimeters:
  sensorState = digitalRead(SENSORPIN);
  // Sensor Beam is Broken


  if (sensorState && !lastState) {
    Serial.println("Unbroken");
  }
  if (!sensorState && lastState) {
    Serial.println("Broken");
    rep=rep+1;
  }
  lastState = sensorState;
  long duration, inches, cm , weight;

  // The sensor is triggered by a HIGH pulse of 10 or more microseconds.
  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
  pinMode(trigPin, OUTPUT);
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the signal from the sensor: a HIGH pulse whose
  // duration is the time (in microseconds) from the sending
  // of the ping to the reception of its echo off of an object.
  pinMode(echoPin, INPUT);
  duration = pulseIn(echoPin, HIGH);

  // convert the time into a distance
  inches = microsecondsToInches(duration);
  cm = microsecondsToCentimeters(duration);
  if (cm < 5)
  {weight= 10;}
  else if (cm>=5 && cm<7)
  {weight= 15;}
  else if (cm>= 7)
  {weight= 0;}
  calories= weight*rep/10;

  //Particle.publish("himanshu2016/lat/calories",+String(calories));
  Serial.print(inches);
  Serial.print("in, ");
  Serial.print(cm);
  Serial.print("cm, ");
  Serial.print(weight);
  Serial.print(" kg, ");
  Serial.print(rep);
  Serial.print(" repition, ");
  Serial.print(calories);
  Serial.print(" calories");
  Serial.println();
  announcedata( calories );

  //else if (cm>=7)
  //{return -1;}
  delay(1000);
}
void announcedata( int calories )
{

  String data = String(calories);
  // and share as a public event
  Particle.publish("himanshu2016/lat",data);

}
long microsecondsToInches(long microseconds)
{
  // According to Parallax's datasheet for the PING))), there are
  // 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
  // second).  This gives the distance travelled by the ping, outbound
  // and return, so we divide by 2 to get the distance of the obstacle.
  // See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
  return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds)
{
  // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  // The ping travels out and back, so to find the distance of the
  // object we take half of the distance travelled.
  return microseconds / 29 / 2;
}
Click to Expand
0

Device 3

Soylent Dispenser


This device is used to dispense the required intake for the user ,based on the workout done by them.Currently,we have gone with dispensing of the soylent,but it can be extended to provide a nutritious dietary system,that also enables the gym goer to take the necessary supplements to enhance his stamina.  It  takes the input from the Lat machine ,in the form of calories expended by the user.Based on the information,the dispenser is made to take a decision as to what is the right quantity of soy-lent needed by the user.Providing this feedback to the user,allows them to easily decide their duet and supplements for a proper and better gym experience.

Components Used:

1.Particle Photon

2.OLED Display Screen

3.Bread Board with Connecting wires

4. Cardboard Prototype 

5.Power Supply

Img 20160302 182001953.thumb  

0
Fritzing for Soylent Dispenser
Cs1.png.thumb
0
Coding for Soylent Dispenser
#include "Adafruit_GFX.h"
#include "Adafruit_SSD1306.h"

#define OLED_DC     D3
#define OLED_CS     D4
#define OLED_RESET  D5
Adafruit_SSD1306 display(OLED_DC, OLED_RESET, OLED_CS);

#define NUMFLAKES 10
#define XPOS 0
#define YPOS 1
#define DELTAY 2

#define LOGO16_GLCD_HEIGHT 16
#define LOGO16_GLCD_WIDTH  16
int calo;

static const unsigned char logo16_glcd_bmp[] =
{ 0B00000000, 0B11000000,
 0B00000001, 0B11000000,
 0B00000001, 0B11000000,
 0B00000011, 0B11100000,
 0B11110011, 0B11100000,
 0B11111110, 0B11111000,
 0B01111110, 0B11111111,
 0B00110011, 0B10011111,
 0B00011111, 0B11111100,
 0B00001101, 0B01110000,
 0B00011011, 0B10100000,
 0B00111111, 0B11100000,
 0B00111111, 0B11110000,
 0B01111100, 0B11110000,
 0B01110000, 0B01110000,
 0B00000000, 0B00110000 };

#if (SSD1306_LCDHEIGHT != 64)
#error("Height incorrect, please fix Adafruit_SSD1306.h!");
#endif

void setup()   {
 display.begin(SSD1306_SWITCHCAPVCC);
 display.clearDisplay();   // clears the screen and buffer
 Particle.subscribe("himanshu2016/lat",myHandler);
 Serial.begin(9600);
}

void loop()
{
  Serial.println("started");
  if(calo<8)
 {
  Serial.println("<8");
 display.setTextSize(2);
 display.setTextColor(BLACK, WHITE);
 display.setCursor(0,2); // 128(<>,◊)64
 display.println("LESS WORK");
 display.setTextSize(2);
 display.setTextColor(WHITE);
 display.setCursor(10,20); // 128(<>,◊)64
 display.println("DISPENSE");
 display.setTextSize(2);
 display.setTextColor(WHITE);
 display.setCursor(20,50); // 128(<>,◊)64
 display.println("200 ml");
 display.display();
 Serial.print (calo);
 delay(1000);
}

 else if(calo>8)
 {
//   if(calories<15)
 Serial.println(">8");
 display.setTextSize(2);
 display.setTextColor(BLACK, WHITE);
 display.setCursor(0,2); // 128(<>,◊)64
 display.println("MORE WORK");
 display.setTextSize(2);
 display.setTextColor(WHITE);
 display.setCursor(10,20); // 128(<>,◊)64
 display.println("DISPENSE");
 display.setTextSize(2);
 display.setTextColor(WHITE);
 display.setCursor(20,50); // 128(<>,◊)64
 display.println("500 ml");
 display.display();
 delay(1000);
 Serial.print (calo);
 //void myHandler(const char *event, const char *data);
  }
//Serial.print(calories);
//Serial.print(" cal ");
}

void myHandler(const char *event, const char *data)
{

Serial.println("received =");
Serial.println( data );
Serial.println( event );
// conver the data to a String type.
String dataStr = data;
// check for error stuff
// if there isn't data do nothing
//if (!data) return;
// We only want to handle events
// From our paired device
// We're not interested in stuff that's come from
// this device ...
//String myID = System.deviceID();
// if the device that sent is this device... ignore. return exits this function
//if( dataStr.indexOf( myID ) > -1 ) return;
// If we get to here, it's an event we care about
//Serial.println( "Not from another ... ");
// Extract the angle from the data string
// by chopping off the piece before the comma
//int index = dataStr.indexOf(",");
//String value = dataStr.substring( 0, index );
int calo = dataStr.toInt();
Serial.println(calo);
}
Click to Expand
0

Website

The entire  process is made accessible for the users through the website-IoTing. All data,from each of the devices,is pushed to the cloud, where it is imported, combined, and analyzed on a user-friendly website.Here,the dynamically changing result for each exercise can be easily viewed by the users.

Iotings site.thumb  

0

Video

0
0

Image Board

In order to develop a better understanding of the scenario,we tried capturing the opportunity through the use of images.  It helped in identifying the key parameters to formulate our solution,some of them being healthy food,having the right portions,gym experience for users,etc...

Final report page 010.thumb  


Final report page 011.thumb  

Img 20160302 181721205.thumb  

0

Reflection and Next Steps


It was observed that developing three concepts in a single ecosystem,was quite challenging . However,after developing the concepts,we realized that they had the potential to be taken further over a longer time frame.This could be done by collecting and analyzing more data ,once the system comes into use,which would lead to precise results.The device configurations and linking can be done by a centralized system like an Admin Panel.We understood that the user experience plays an important role,when the IoT technology is developed.So,the proposed devices could be upgraded further using advanced technology and made aesthetically appealing.Also the food dispenser technique,could be improved and new concepts and feedback systems can be incorporated in the same.

Working as team of 10,with greater deliverable in a shorter span of time,helped a lot in the brainstorming and concept development stages.We understood the possibility of creating an entire eco-system using the Internet of Things.

Final report page 016.thumb  

x
Share this Project

Courses

49-713 Designing for the Internet of Things

· 2 members

This course charts the emergence of the now "connected world" to explore the possibilities for future products and connected spaces.


Focused on
About

A connected gym ecosystem that measures and uses workout data and biological parameters to optimize workout sessions and nutrient intake by supplying comprehensive performance feedback to the user.