Group Research Project Reflection – Sagar Risal

Interaction is very broad, but the way that I’ve come to define it is, an action from a user followed from a response from certain object. The reason I see it this broad is because instead of just defining interaction to a confined definition, I see it more as a open definition that can in turn be seen in terms of levels of interaction.

When researching projects for inspiration for our group project, two really stuck out to me in the way that the interact with the user, as well as the way that it can benefit the user. These were TAMI, an interface that helps students better understand calculus, with both physical elements as well as a digital display, as well as the Oculus Rift, a virtual reality headset. As Crawford states in his book Art of Interactivity, there are degrees to interaction, and these two projects are perfect examples of those. TAMI I would consider to have a very high level of interaction, since it combines both physical and digital elements to it’s interface, as well as the interaction of knowledge that the user gains when using the product. It’s very high level interaction allows for students to better understand the intricacies of graphing certain formulas, because it allows the user to interact with the product in different ways in which the user feels fit. The oculus on the other hand is a little bit lower in level in interaction as a product itself, since it can only show you the view of what you are doing, but it shows how if one can combine the oculus with other types of technologies, one can reach a higher form of interaction. 

Our group project was called Knowledge Transmitter 2.0, since the first one killed someone due to some malfunctions, showing how even 100 years in the future there are still missteps with technology. The device is meant to transfer the information from books into ones brain, as to gain that new information and use it to create new ideas. The device transfers all the information from the book into ones head, but that information disappears from one’s memory unless bought again, making the seller make more money.

I would consider this project to have a high level of interaction since, just like reading a book, there is a transference of information from one object to another, and the output is what the user does with that information, as well as the information that the user chose to receive. Just like when one learns something new, it is up to them to come up with how they want to use this new information and for what purpose could it serve to better themselves interact with the information given as well as what they want to forge their output of that information and knowledge. 

Works Cited: 

Crawford. “What Exactly Is Interactivity.” The Art of Interactivity, pp. 1–6. 

https://www.creativeapplications.net/openframeworks/tami-an-intuitive-approach-to-the-learning-of-trigonometry/

https://www.oculus.com/?locale=en_US 

LED Biking Jacket – Sagar Risal – Rudi

When first creating this jacket I wasn’t really invested in the material of the jacket, since I knew I just needed any jacket that could hold all the circuitry that it would have. I also recognized that the jacket I would need would have to be of a thinner material so that the LEDs could shine through, so I thought it would maybe be a good idea to put a bigger jacket over it, as to hide the wiring. In the end I ended up not having the bigger jacket over it, since I thought I did a good job of hiding the sewing  I did on the jacket. I also knew the user would need a way to turn on the indicators in a way that would be easy for the user to do as well as safe for when they would be biking. For this reason I decided to add gloves to the jacket so that the user had access to buttons.  I then decided that I would put the buttons on the gloves near the finger so that the user had very easy access to pressing the button and indicating in which direction they were going. I thought of maybe purchasing a real biking jacket with actual biking gloves, as to make the outfit feel more legitimate, but the overall cost steered me to instead find a cheap jacket. If I had a lot more time, and money, I would’ve loved to integrate the wires inside the actual jacket material, so they wouldn’t show.

While creating the jacket there were three main humps. These were, the actual design of jacket and how I would make it and how it would look, the communication between Arduino and Processing and how it would play into the jacket, as well as how the lights would look. These three were all huge parts of the production of the jacket and how it would turn out in the end. One of the biggest struggles for me at first was how I would be able top have LEDs on the back of the jacket showing animations. At first I thought having an LED matrix on the back of the jacket would be a good idea, but after looking at the schematics of it and how much time it would take to do it, I thought that it would be better to have four LED strips and control each individual LED strip to make the desired animations. This would make it a lot easier to make the jacket itself, as well as code for the animations. This decision was a big part of how I would proceed to do my project, since the matrix idea was more Processing based, while having four LED strips would be handled majority by Arduino. I would say that I ended up coming successful in these three humps, except for the fact that I didn’t have time to code for the ability for the user to change the colors of the jacket, which I thought would be a really nice addition. 

Matrix Sketch                                      Four LED Strips Sketch

IMG_4887

In user testing I was missing majority of my project, and though most students liked the idea of LEDs on a jacket and being able to control them for the practical purpose of riding a bike, many of the teachers wanted me to add more elements to the jacket, which is where one of my proudest success came from. Ironically the success wasn’t from the jacket but instead the interface of which one could interact on Processing with the jacket.  I was really proud of the interface because of how it complemented the theme of the jacket, as well as do nice job of showing the interaction between the user and the jacket through the computer. The interface allowed me to play more with the theme that the jacket would follow, as well as how the user would be able to interact with the jacket, while still following the practical use of the jacket itself.  

When I set out to make this project I wanted to make a jacket that could be worn by bikers, so that when they bike at night they are able to be seen by cars as well as by other bikers who, especially at night, don’t know in which direction one is turning. After witnessing many biking accidents here in China, as well as being in a couple myself, I noticed that most of them happen at night    where visibility is low and riding itself is difficult because of the fact bikes have to share the road with pedestrians as well as electric scooters. I wanted an easy as well as cool way in which bikers could safely traverse the streets without feeling like they can’t be seen. I also wanted the driver to interact with the jacket itself, which is why I added buttons, as well as an interface where the user can change the animations to what they want. I have always defined interaction in levels instead of just having interaction, or not having. Obviously just pressing buttons on a jacket isn’t much of an interaction, but when thinking about the bigger picture of how one is able to choose what animations they want on their jacket as well how the usage of the jacket itself and how it lends to interacting with people on the streets while biking, it shows how just be able to control what your clothes do on your body you are able to interact with more than just two buttons on your gloves. 

During my final presentation many of my peers enjoyed the project, but also offered many recommendations that I myself wanted to include in the project but I couldn’t because of time. This included a brake light, as well as feedback for the user when pressing the buttons, so that the user could have some indication that the lights were working in the right way, since the user cannot see the lights themselves. These were all recommendations that I thought were very helpful towards how I could improve the jacket. If I had more time with this project I would’ve loved to add more customization options, as well as take the recommendations I received into my project. I would have also loved to improve on the look of the jacket itself, so that it can look and feel like a regular bike jacket but have LEDs as well. 

One thing that I definitely learned from this project is that combining technology with fashion, or just clothes in general, takes a lot of time, effort and patience. Not everything works the first time and one has many different factors when designing a meaningful way to use technology in ones clothes. The whole process is very tiresome but very rewarding when one is able to do it successfully, making the technology work meaningfully as well as look good.   Clothing and technology, while two very different things, are a lot more similar than one thinks. While humans start using technology more and more in their daily lives, it should be natural that we start adapting it to fit our clothes, which is also necessary for every day use. The more and more comfortable we get with technology and how we can implement it into what we wear, the easier daily life can become, with having simple tasks be able to be done from our clothes instead of our phone or additional technology. My LED biking jacket shows something as simple as a jacket with lights can be used to help solve issues of safety on the road, as well as offer a different style to the bikers who use it. As technology gets better and more incorporated into what we wear, one will be able to interact easier with more from their daily lives, from the simple action of just wearing their clothes. These interactions we have with what we wear, not only can look really cool, but also have a big impact with how we interact with each other in the future.

Arduino Code: 

#include <FastLED.h>
#define LED_PIN 7
#define LED_PIN_2 6
#define LED_PIN_3 5
#define LED_PIN_4 4
#define NUM_LEDS 18

#define NUM_OF_VALUES 3 /** YOU MUST CHANGE THIS ACCORDING TO YOUR PROJECT **/
/* This is the array of values storing the data from Processing. */
int values[NUM_OF_VALUES];
int valueIndex = 0;
int tempValue = 0;

CRGB leds[NUM_LEDS];
CRGB leds_2[NUM_LEDS];
CRGB leds_3[NUM_LEDS];
CRGB leds_4[NUM_LEDS];

int leftButton = 8;
int rightButton = 9;

void setup() {
Serial.begin(9600);
values[0] = 1;
values[1] = 1;
values[2] = 1;
FastLED.addLeds<WS2812, LED_PIN, GRB>(leds, NUM_LEDS);
FastLED.addLeds<WS2812, LED_PIN_2, GRB>(leds_2, NUM_LEDS);
FastLED.addLeds<WS2812, LED_PIN_3, GRB>(leds_3, NUM_LEDS);
FastLED.addLeds<WS2812, LED_PIN_4, GRB>(leds_4, NUM_LEDS);

//LEFT SIGNAL
pinMode(leftButton, INPUT_PULLUP);

//RIGHT SIGNAL
pinMode(rightButton, INPUT_PULLUP);

}

void loop() {

getSerialData();

if (digitalRead(leftButton) == LOW) {
//Play left animation
if (values[0] == 1) {
Left1();
Left1();
Left1();

}
if (values[0] == 2) {
Left2();
Left2();
Left2();

}
if (values[0] == 3) {
Left3();
Left3();
Left3();

}
}
else if (digitalRead(rightButton) == LOW) {
//Play right animation
if (values[2] == 1) {
Right1();
Right1();
Right1();

}
if (values[2] == 2) {
Right2();
Right2();
Right2();

}
if (values[2] == 3) {
Right3();
Right3();
Right3();

}
}
else {
if (values[1] == 1) {
Forward1();
}
if (values[1] == 2) {
Forward2();
}
if (values[1] == 3) {
Forward3();
}
}

}

void Direction1() {

for (int i = 18; i >= 0; i–) {
leds[i] = CRGB (255, 0, 0);
FastLED.show();
delay(40);
}

for (int i = 18; i >= 0; i–) {
leds[i] = CRGB (0, 0, 0);
FastLED.show();
delay(40);
}

}

void Direction2() {

for (int i = 0; i <= 18; i++) {
leds[i] = CRGB ( 255, 0, 0);
FastLED.show();
delay(40);
}
for (int i = 0; i <= 18; i++) {
leds[i] = CRGB ( 0, 0, 0);
FastLED.show();
delay(40);
}

}

void Blink() {

leds[0] = CRGB(255, 0, 0);
leds[1] = CRGB(255, 0, 0);
leds[2] = CRGB(255, 0, 0);
leds[3] = CRGB(255, 0, 0);
leds[4] = CRGB(255, 0, 0);
leds[5] = CRGB(255, 0, 0);
leds[6] = CRGB(255, 0, 0);
leds[7] = CRGB(255, 0, 0);
leds[8] = CRGB(255, 0, 0);
leds[9] = CRGB(255, 0, 0);
leds[10] = CRGB(255, 0, 0);
leds[11] = CRGB(255, 0, 0);
leds[12] = CRGB(255, 0, 0);
leds[13] = CRGB(255, 0, 0);
leds[14] = CRGB(255, 0, 0);
leds[15] = CRGB(255, 0, 0);
leds[16] = CRGB(255, 0, 0);
leds[17] = CRGB(255, 0, 0);

FastLED.show();
delay(500);
leds[0] = CRGB(0, 0, 0);
leds[1] = CRGB(0, 0, 0);
leds[2] = CRGB(0, 0, 0);
leds[3] = CRGB(0, 0, 0);
leds[4] = CRGB(0, 0, 0);
leds[5] = CRGB(0, 0, 0);
leds[6] = CRGB(0, 0, 0);
leds[7] = CRGB(0, 0, 0);
leds[8] = CRGB(0, 0, 0);
leds[9] = CRGB(0, 0, 0);
leds[10] = CRGB(0, 0, 0);
leds[11] = CRGB(0, 0, 0);
leds[12] = CRGB(0, 0, 0);
FastLED.show();
delay(500);
}

void getSerialData() {
while (Serial.available() > 0) {
char c = Serial.read();
//switch – case checks the value of the variable in the switch function
//in this case, the char c, then runs one of the cases that fit the value of the variable
//for more information, visit the reference page: https://www.arduino.cc/en/Reference/SwitchCase
switch (c) {
//if the char c from Processing is a number between 0 and 9
case ‘0’…’9′:
//save the value of char c to tempValue
//but simultaneously rearrange the existing values saved in tempValue
//for the digits received through char c to remain coherent
//if this does not make sense and would like to know more, send an email to me!
tempValue = tempValue * 10 + c – ‘0’;
break;
//if the char c from Processing is a comma
//indicating that the following values of char c is for the next element in the values array
case ‘,’:
values[valueIndex] = tempValue;
//reset tempValue value
tempValue = 0;
//increment valuesIndex by 1
valueIndex++;
break;
//if the char c from Processing is character ‘n’
//which signals that it is the end of data
case ‘n’:
//save the tempValue
//this will b the last element in the values array
values[valueIndex] = tempValue;
//reset tempValue and valueIndex values
//to clear out the values array for the next round of readings from Processing
tempValue = 0;
valueIndex = 0;
Flash();
Flash();
Flash();
break;
//if the char c from Processing is character ‘e’
//it is signalling for the Arduino to send Processing the elements saved in the values array
//this case is triggered and processed by the echoSerialData function in the Processing sketch
case ‘e’: // to echo
for (int i = 0; i < NUM_OF_VALUES; i++) {
Serial.print(values[i]);
if (i < NUM_OF_VALUES – 1) {
Serial.print(‘,’);
}
else {
Serial.println();
}
}
break;
}
}
}

Processing Code: 

import processing.serial.*;

int NUM_OF_VALUES = 3; /** YOU MUST CHANGE THIS ACCORDING TO YOUR PROJECT **/

Serial myPort;
String myString;

// This is the array of values you might want to send to Arduino.
int values[] = {1,1,1};
char screen = ‘H’;

void setup() {

size(1440, 900);

printArray(Serial.list());
myPort = new Serial(this, Serial.list()[ 5 ], 9600);
// check the list of the ports,
// find the port “/dev/cu.usbmodem—-” or “/dev/tty.usbmodem—-”
// and replace PORT_INDEX above with the index of the port

myPort.clear();
// Throw out the first reading,
// in case we started reading in the middle of a string from the sender.
myString = myPort.readStringUntil( 10 ); // 10 = ‘\n’ Linefeed in ASCII
myString = null;
imgLeft = loadImage(“LeftReal.jpg”);
imgMenu = loadImage(“Menu.jpg”);
imgForward = loadImage(“Forward.jpg”);
imgRight = loadImage(“Right.jpg”);
}

void mousePressed() {
if (screen == ‘H’) {
mousePressHome();
} else if (screen==’L’) {
mousePressLeft();
} else if (screen==’F’) {
mousePressForward();
} else if (screen==’R’) {
mousePressRight();
}

//sendSerialData();
}

void sendSerialData() {
String data = “”;
for (int i=0; i<values.length; i++) {
data += values[i];
//if i is less than the index number of the last element in the values array
if (i < values.length-1) {
data += “,”; // add splitter character “,” between each values element
}
//if it is the last element in the values array
else {
data += “n”; // add the end of data character “n”
}
}
//write to Arduino
myPort.write(data);
}

void echoSerialData(int frequency) {
//write character ‘e’ at the given frequency
//to request Arduino to send back the values array
if (frameCount % frequency == 0) myPort.write(‘e’);

String incomingBytes = “”;
while (myPort.available() > 0) {
//add on all the characters received from the Arduino to the incomingBytes string
incomingBytes += char(myPort.read());
}
//print what Arduino sent back to Processing
print( incomingBytes );
}

void draw()//Title Screen
{
if (screen == ‘H’) {
drawHome();
} else if (screen == ‘L’) {
drawLeft();
} else if (screen == ‘F’) {
drawForward();
} else if (screen == ‘R’) {
drawRight();

}

// echoSerialData(20);
}

void keyPressed() {
printArray(values);
sendSerialData();
}

Recitation 10: Workshops – Sagar Risal

Materials: 

Arduino Kit 

Processing

Documentation: 

I chose to do the serial communication workshop in this recitation, where we reviewed serial communication between Arduino and Processing as well as learned how to use maps in our code, and what are some of the benefits of it. Serial communication will be a big part of my project, since I need to be able to have Arduino speak to Processing, as well as have Processing speak to Arduino, which is why I thought it would be a good idea to review this information. Map seemed to be a very useful function, but I don’t think it would be that useful for my specific project, we went over how it could be used in different ways but none of them matched up in the way in which I could use it for my own project, but it was still a good way to see how maybe I could put into my project and test out different elements in what I want to do. 

Recitation 9: Media Controller – Sagar Risal

Materials: 

Arduino Kit 

Processing

Media Controller: 

In this recitation we had to have Arduino control a certain aspect of an image from processing. I used a pentameter to control the pixels in my webcam so that the lower the pentameter was the less pixels there were and the higher it was the more complete the webcam image would look. I had to use specific dimensions for the webcam to work with the amount of pixels I wanted to use, since each pixel had to be a certain size to fill the screen perfectly. 

Documentation: 

After reading Computer Vision I understand how computers and humans can interact in ways that both the computer and person can understand what each other are doing. This can be done with the computer being able to understand ones motion or how certain facial features move, and a human can understand the computer because of the visual that it projects. For example, in my recitation I knew that if I move the pentameter my image would become more pixelated, what the computer understood was that the more I moved the pentameter the more pixels it would have to add to the image. Through the visual aid of what the computer projected I was able to understand how the computer would react to something I did, and in turn the computer would react to what I inputed, causing interaction between me and the computer.  

IMG_4462

Final Project – Essay – Sagar Risal

LED Biking Jacket 

This jacket would be primarily for bikers who like biking at night, since the jacket would offer the ability to alert other bikers as well as cars where they are on the road. I researched on which field wearable LEDs could be used, and biking was one where there is a lot potential usage of this technology. There are many accidents regarding drivers not being able to see bikers, and while there are jackets that have reflective material on them, there aren’t ones that can tell which direction one is turning, which would help alert people behind them. A lot of bike accidents don’t usually come from cars, but instead other bikes who didn’t know someone in front of them was turning, so this jacket would have LEDs on the back of the jacket that one could control to tell in which direction they are going as well as alert drivers of their position which could help cause less accidents. 

To make this jacket I took in consideration what a bike rider would lack at night. Obviously the ability to see clearly is important, but what is more important than that is the driver’s safety. If a car or other bikers aren’t able to see a biker at night then the bike rider is much more likely to get hit. If the biker is able to wear a jacket that illuminates them then the risk of getting hit goes down tremendously and the biker’s safety is better ensured. For turning left and right, the biker could have special buttons on the gloves of the jacket as to provide an easy access to a sort of “turn signal” for the biker. This also provides another level of safety towards the biker since other bikers in the back would be able to know if the biker is turning or not through the LEDs on the biker’s back. 

For me to complete all the things I need to do in time, I think the biggest area I would need to work on is getting the LED panels to work wirelessly, so that I can integrate them to the jacket. The second biggest thing would probably be combining the buttons and hardware into the jacket so that the design can work well and look good. Other than that, the code for the actual jacket itself, shouldn’t take too long. I just would need to create different colored screens on processing, as well as different patterns that are able to change through Arduino. Since we have gone over most of it in past recitations this part shouldn’t cause that much difficulty.  

While trying to come up with a good idea for my final project, the idea of wearable LEDs kept popping up into my head, since I loved how they looked and just imagining how cool they would look if one wore them made me want to research on what I could make with LEDs. Most wearable LEDs are used for fashion or costumes but when I stumbled upon the biking jackets that have reflective panels, I wondered if maybe they could look better and be more intuitive with LEDs instead of just reflective panels. I have also been biking a lot more in Shanghai since the cost of renting a bike is very cheap and they are almost everywhere. It was also part of this reason that I thought that doing something with bikes would be a good idea. In the reading for Human Centered Design it explains how  “Immersing yourself in another world not only opens you up to new creative possibilities, but it allows you to leave behind preconceived ideas and outmoded ways of thinking”. This mindset was definitely a key part in choosing to do this project and helped me come up with this idea for a LED biker jacket. After witnessing so many near misses or even bikers getting hit just in my time here in the city, I thought adding certain interactive elements to the biker’s jacket could help improve the safety of not only bikers, but the people who also share the road and sidewalks with them. Hopefully this awareness in biker safety can help cause less accidents and also be a new style for bikers around the world.