Author: Yihan Meng

Through the past weeks’ learning experience and my own research, I have gained a better understanding of the term “interaction” and it is interesting to see how my definition of interaction has changed during this semester. In this post, I will first go back to my previous ideas on “interaction”, followed will be a display of my research and some analysis on how “interaction” is presented by referring to two projects I found interesting. Finally, I will come to the stage of clarifying my new definition of “interaction”.
When I first thought about interaction before the midterm project, all I based on was the materials I read and the very limited researches I made. I defined it as “a series of processes involving two or more actors’ effort to achieve a mutual goal (for entertainment or live more effectively and conveniently) and is based on the ability, which creatures or artificial objects possess, to give reactions to external stimuli (to each other) through thinking or processing”. Not soon after that, when I finished working on my midterm project, I modified my definition according to how we worked on our project. Being conscious about emotional feelings or ideological morality has become an important part of my definition since it is the basis of giving reactions accordingly.
I was quite satisfied with that definition. However, after I did more researches, my opinions changed slightly again. For this second research in this semester, I believe it would be helpful for me to see how the mass thinks about the idea of “interactive project”, therefore, I typed “interactive” in the searching bar of Youtube. Here I have some interesting and inspiring results for that. One video that ranked actually pretty high in the searching result, yet I see it as the counterexample of interactive. It is called “learn how to make interactive projects”, video uploaded by Technique Tuesday. The video teaches viewers how to make a so-called “interactive” notes or cards. While I disagree with the producer’s idea of calling it interactive since, as what I see with the video, the whole project does not include the part of the object giving feedback or reaction according to how people act. The card thing is interesting and entertaining, but it is not what’s most important for interaction.

So what is important? The other video I found could answer this question perfectly: “DIY Interactive Coffee Table”. After seeing the introduction of the table, I feel instantly that this is the project that could satisfy all the requisition of being interactive. I than deeper analyzed it, and here is the things I found that made it interactive: 1. The clear sign of receiving the signal or detecting the action of people. When people press the remote, the light of the table would change to the color that is decided by people. 2. The visible signal of giving back a reaction. The instant one cup is placed on the table, the table would change the color of light in that specific square. 3. The application of this project could suit the original purpose of making this area in the living room more vivid perfectly. From these things in the coffee table project and what I read in readings, I find what is most important for interaction. Bret Victor stated in his article about interaction that “…visions matter. Visions give people a direction and inspire people to act, and a group of inspired people is the most powerful force in the world…I really want it to be something worthwhile. Something that genuinely improves how we interact.” (A Brief Rant on the Future of Interaction Design) It is hard, even impossible for us to see the interconnection between objects and virtual information going back and forth. Without sensing it, the process of interaction will not be whole. Therefore, the ability to give responses or reaction repetitively and the sign of showing it with sensible signals, especially vision, are the most important elements of things being “interactive”.

So here comes my new definition of interaction: interaction is a series of processes concerning emotional feelings or ideological morality which could go repetitively involving two or more actors’ effort to achieve a mutual goal through thinking or processing and the process of it is presented with sensible signals.

Recitation Exercise

1. Deciding to do something totally new instead of using the one I worked on last recitation.
2. Developing the idea of using keyboard and mouse to make a figure of a person move.
3. I first wanted to apply the bouncing ball code we made in class and creating a game of player controlling the person to avoid the bouncing ball. However, I find that none of the functions we had learned could be used to detect if the ball had hit the person. I asked Young for help and he gave me a hint to use the “dist()” function. I successfully figured out the proper way to use it by referring to references for Processing. However, it seemed not working well and correcting it is far too complicated for me. After several attempts, I decided to have a change.(source:https://processing.org/reference/dist_.html)
4. So, I changed my ideas. Still using the person figure, I made a model of crossing the road. By pressing right and left, the player can make the figure move. By pressing the mouse, the person will be controlled to cross the road.

(This is my first attempt. One problem is that as soon as the mouse is pressed, the person would go straight forward even when the mouse stop pressing and the light turns red again.)

(So here comes the modified edition. I add several lines to make the person stop going forward when the mouse stop pressing. I also made some changes of the items in the picture to make it more like a road.)

code: https://gist.github.com/Ellie-1809/fe03cb09b33005c92b506c71829c2810

Recitation Homework

1. Create a Processing sketch with a circle or square at the center of the screen.
2. Next, modify that Processing sketch so that the circle or square periodically expands and contracts.
3. Then, modify the Processing sketch so that the outline changes color smoothly.
4. Finally, modify that Processing sketch so that the circle or square moves around the canvas based on keyboard’s arrow key input.
5. *Bonus: I tried to make a border by setting a certain range for x value and y value of the center point of the circle.

code:https://gist.github.com/Ellie-1809/8e89c4f4738ebfb0569c5dab1da1dfa8

Things I learned: the most valuable experience I had during the process of making my little game is learning to use the function of “dist()”. Though it did not work well, my experience of reading the instructions and trying to figure out how to apply it prepares me better for future exploring and self-learning. Also, I learned to use multiple ways to display the same result(for example using for() function as substitutes for repetitive coding), which is an important thing in modifying the code(e.g.showed below).

Meanwhile, I also figured our one thing that I failed to fully understand in class – how Processing makes figures seem like moving. Many frames result in a seemingly “moving” picture and that is why we have to reset the background color at the beginning of draw() to avoid multiple frames existing on the same canvas.

Functions: self-defined functions(drawPerson(), drawTrafficlight(), etc.)

               For(){}(loop function)

               If(){}function

               keyPressed(){}function

               colorMode()function

               stroke() (this may not be much interesting but definitely useful and basic)

other resources used: color reference: http://tool.oschina.net/commons?type=3

I chose Josef Albers’ Penetrating (B) as my motif. I chose this image because it is built with the simplest forms, shapes and colors but the outcome is surprisingly full of aesthetics. Since I only have the very basic knowledge and applications of Processing, I think choosing this image as my motif could both allow me to apply my learning outcomes and would not add too much difficulty for me to code. 

I would like to draw a similar image as Penetrating (B) but with a different color theme which were brighter. I divide my process into three parts — the background, the shape and the color. After determine the size of background, I chose the color of 255,200,200 (pink) as the color of it. Then I started drawing the shape. I divided the front shape into several parts to make the code simpler and easier for me to write. This stage took me a lot of time to determine the position of the shapes, their relative locations and angle of inclination between different lines. After all the figures were completed, the final step was to decide the color of each part. I searched for a comparison table on the internet to find the code of the color I had chosen.

As I aimed, my image had the same form and shapes as the motif but was filled in different colors to present a sense of brightness and warmness. I think, with the very limited knowledge that I have learned, Processing is not a good tool for drawing and realizing my designing since I could simply use pens and rulers to do the same thing in a faster and more convenient way. However, I do agree that Processing could provide a better platform for complicated designs which require more accurate position of each line. It could also be a great tool to realizing dynamic designs which is beyond the capability of simply drawing a single picture on one piece of paper.

My Code:

size(600,600);

background(255,200,200);

//background1

noStroke();

fill(127,0,0);

beginShape();

vertex(100,50);

vertex(460,50);

vertex(450,100);

vertex(600,100);

vertex(550,300);

vertex(50,300);

endShape();

triangle(0,300,50,300,0,450);

//background2

beginShape();

vertex(0,450);

vertex(220,450);

vertex(210,500);

vertex(500,500);

vertex(550,300);

vertex(600,300);

vertex(600,600);

vertex(0,600);

endShape();

stroke(0);

fill(205,193,197);

beginShape();

vertex(150,100);//1

vertex(250,100);//2

vertex(400,200);//3

vertex(350,450);//4

vertex(250,400);//5

vertex(220,450);//6

vertex(70,350);//7

vertex(150,100);

endShape();

beginShape();

vertex(230,130);//1

vertex(530,130);//2

vertex(480,400);//3

vertex(250,400);//4

vertex(170,350);//5

vertex(230,130);//6

endShape();

fill(205,155,155);

beginShape();

vertex(150,100);

vertex(250,100);

vertex(297,131);

vertex(230,130);

vertex(191,270);

vertex(96,270);

endShape();

beginShape();

vertex(297,131);

vertex(530,130);

vertex(504,270);

vertex(387,270);

vertex(400,200);

endShape();

fill(139,105,105);

beginShape();

vertex(230,130);

vertex(297,131);

vertex(400,200);

vertex(383,290);

vertex(187,290);

endShape();

stroke(0);

line(400,200,350,450);

The original idea of making something entertaining was raised by my partner Robert. Based on that idea, we made a lot of efforts to make our project more interactive and practical. In my previous researches, one thing that I learned inspired me a lot in the designing process of our project. In many projects that aims at entertaining people, one common characteristic appears repeatedly. That is, the machine not only have a mutual final goal with the player, but would also set many barriers to, to some extent, prevent the players from accomplish their goal. Though the process of making achievements becomes more difficult, it stimulates the players’ wish to win and gets them immersed in the game. For example, in the design of “Anti-Drawing Machine” (Created by Soonho Kwon, Harsh Kedia and Akshat Prakash), the inventor purposely gets the machine distract people from drawing things. It turns out that most people get even more enthusiastic and joyful in creating a picture with the machine. Therefore, from my perspective, creating barriers for users are equally important as sharing a mutual goal and reacting accordingly in an interactive project for entertainment since it gets people’s emotional feelings involved. My definition of interaction was thus enriched: Interaction is a series of processes involving two or more actors’ effort to achieve a mutual goal (for entertainment or live more effectively and conveniently) and be conscious about emotional feelings or ideological morality by giving reactions to external stimuli (to each other) through thinking or processing. Based on this idea, we set a final goal of heart rate that is higher than usual to make users pay more effort to achieve that, at the same time obtain a sense of joy. As a game, the project is intended for people who is curious and passionate about using their body. by using visible components to represent heartbeat, it could satisfy people’s desire of viewing the invisible things happening in their bodies and use it to achieve something.

We had great consideration on choosing our components. We chose LEDs and a fan to represent the heart rate based on two criteria: visually attractive or vivid and being easy to understand. The colorful LEDs add to the aesthetics of our project and the fan, which could give wind, is placed at the final goal – heart rate of 140 with the music, to give sense of success and reward. For our project, we would like users to enjoy playing with it and could sense the change between each stage. Therefore, in our design, we cut a rectangle to place the row of LEDs and a hole for the fan. We had them placed in a single line to show the linear change of heart rate. Also, we cut a few holes at the back of the box to let the music be clearly heard to strengthen the feeling of success.

From my perspective, the most significant step in our production is how we managed to present the heart rate. At first, we intended to use an LCD to directly print the heart rate. However, we then give it up for two reasons. Firstly, the circuit and code of LCD in Arduino is too complicated exceed our capability. Secondly, we found it unnecessary to use LCD to directly show the heart rate since we do not really need precise numbers. Rather, we use a row of LEDs to show the raise of heart rate, which involves more visualized signals and aesthetics. Apart from this process of figuring how to represent the heart rate, we also made a lot of adjustments according to feedback obtained from User Testing Session. The most important adjustment was the “instructions” to use the machine. Since we only designed the project based on our presupposed ideas and neglect the experience of users when designing, a lot of users who did not have previous experience of using ear-clip had no idea how to even start running the machine and some expressed their confusion on the meaning of the fan and LEDs. We then realize the importance of accessibility of the project. After receiving feedbacks, we added more information like printing the words on the box, 3D-printing an ear model with the ear-clip placed on and printing the number of heart rate under the LEDs and the fan to guide users on using the machine and added to its accessibility. These adjustments were of great use and in the presentation, peers showed much interest in our project and the 3D-printed ear model received high praise.

The goal of our project is to create something using heart rate that is both entertaining and could motivate people to work out. Our machine provides a mutual goal of achieving a certain heart rate with users while also create some barriers to stimulate people’s emotional feelings, which aligns perfect with my definition of interaction. From the ultimate results in live demo and presentation, I am more than delightful to find that, though there are still things that could be improved, people’s reaction, including their interest and effort in raising the heart rate and their feeling of joy, had perfectly reached our expectation. If we have more time, I would like to add a sign with words like “congratulations” written on, which would show up after people reaching the heart rate of 140 controlled by the stepper motor. From the process of making the project, I have realized the importance of the accessibility of machines and the ability to present data in multiple and vivid ways. Our project and the idea behind it are actually more than a “game”. The heartbeat is a very precise and transparent element that could represent a lot of things in real life. The emotional feelings, the health condition, the capability of dealing with things… Encouraging people to work out is just a small aspect of its use. Such machine could be applied to fitness equipment, making the process more fun. It could also be used in hospitals to encourage young patients to willingly receive the detection and treatment. We are already living in a stressful society and having pressure on everything. Why not make some necessary experience a little bit more joyful?

Code:

#define NOTE_B0  31

#define NOTE_C1  33

#define NOTE_CS1 35

#define NOTE_D1  37

#define NOTE_DS1 39

#define NOTE_E1  41

#define NOTE_F1  44

#define NOTE_FS1 46

#define NOTE_G1  49

#define NOTE_GS1 52

#define NOTE_A1  55

#define NOTE_AS1 58

#define NOTE_B1  62

#define NOTE_C2  65

#define NOTE_CS2 69

#define NOTE_D2  73

#define NOTE_DS2 78

#define NOTE_E2  82

#define NOTE_F2  87

#define NOTE_FS2 93

#define NOTE_G2  98

#define NOTE_GS2 104

#define NOTE_A2  110

#define NOTE_AS2 117

#define NOTE_B2  123

#define NOTE_C3  131

#define NOTE_CS3 139

#define NOTE_D3  147

#define NOTE_DS3 156

#define NOTE_E3  165

#define NOTE_F3  175

#define NOTE_FS3 185

#define NOTE_G3  196

#define NOTE_GS3 208

#define NOTE_A3  220

#define NOTE_AS3 233

#define NOTE_B3  247

#define NOTE_C4  262

#define NOTE_CS4 277

#define NOTE_D4  294

#define NOTE_DS4 311

#define NOTE_E4  330

#define NOTE_F4  349

#define NOTE_FS4 370

#define NOTE_G4  392

#define NOTE_GS4 415

#define NOTE_A4  440

#define NOTE_AS4 466

#define NOTE_B4  494

#define NOTE_C5  523

#define NOTE_CS5 554

#define NOTE_D5  587

#define NOTE_DS5 622

#define NOTE_E5  659

#define NOTE_F5  698

#define NOTE_FS5 740

#define NOTE_G5  784

#define NOTE_GS5 831

#define NOTE_A5  880

#define NOTE_AS5 932

#define NOTE_B5  988

#define NOTE_C6  1047

#define NOTE_CS6 1109

#define NOTE_D6  1175

#define NOTE_DS6 1245

#define NOTE_E6  1319

#define NOTE_F6  1397

#define NOTE_FS6 1480

#define NOTE_G6  1568

#define NOTE_GS6 1661

#define NOTE_A6  1760

#define NOTE_AS6 1865

#define NOTE_B6  1976

#define NOTE_C7  2093

#define NOTE_CS7 2217

#define NOTE_D7  2349

#define NOTE_DS7 2489

#define NOTE_E7  2637

#define NOTE_F7  2794

#define NOTE_FS7 2960

#define NOTE_G7  3136

#define NOTE_GS7 3322

#define NOTE_A7  3520

#define NOTE_AS7 3729

#define NOTE_B7  3951

#define NOTE_C8  4186

#define NOTE_CS8 4435

#define NOTE_D8  4699

#define NOTE_DS8 4978

#define melodyPin 3

int melody[] = {

 NOTE_E7, NOTE_E7, 0, NOTE_E7,

 0, NOTE_C7, NOTE_E7, 0,

 NOTE_G7, 0, 0,  0,

 NOTE_G6, 0, 0, 0,

 NOTE_C7, 0, 0, NOTE_G6,

 0, 0, NOTE_E6, 0,

 0, NOTE_A6, 0, NOTE_B6,

 0, NOTE_AS6, NOTE_A6, 0,

 NOTE_G6, NOTE_E7, NOTE_G7,

 NOTE_A7, 0, NOTE_F7, NOTE_G7,

 0, NOTE_E7, 0, NOTE_C7,

 NOTE_D7, NOTE_B6, 0, 0,

 NOTE_C7, 0, 0, NOTE_G6,

 0, 0, NOTE_E6, 0,

 0, NOTE_A6, 0, NOTE_B6,

 0, NOTE_AS6, NOTE_A6, 0,

 NOTE_G6, NOTE_E7, NOTE_G7,

 NOTE_A7, 0, NOTE_F7, NOTE_G7,

 0, NOTE_E7, 0, NOTE_C7,

 NOTE_D7, NOTE_B6, 0, 0

};

int tempo[] = {

 12, 12, 12, 12,

 12, 12, 12, 12,

 12, 12, 12, 12,

 12, 12, 12, 12,

 12, 12, 12, 12,

 12, 12, 12, 12,

 12, 12, 12, 12,

 12, 12, 12, 12,

 9, 9, 9,

 12, 12, 12, 12,

 12, 12, 12, 12,

 12, 12, 12, 12,

 12, 12, 12, 12,

 12, 12, 12, 12,

 12, 12, 12, 12,

 12, 12, 12, 12,

 9, 9, 9,

 12, 12, 12, 12,

 12, 12, 12, 12,

 12, 12, 12, 12,

};

int underworld_melody[] = {

 NOTE_C4, NOTE_C5, NOTE_A3, NOTE_A4,

 NOTE_AS3, NOTE_AS4, 0,

 0,

 NOTE_C4, NOTE_C5, NOTE_A3, NOTE_A4,

 NOTE_AS3, NOTE_AS4, 0,

 0,

 NOTE_F3, NOTE_F4, NOTE_D3, NOTE_D4,

 NOTE_DS3, NOTE_DS4, 0,

 0,

 NOTE_F3, NOTE_F4, NOTE_D3, NOTE_D4,

 NOTE_DS3, NOTE_DS4, 0,

 0, NOTE_DS4, NOTE_CS4, NOTE_D4,

 NOTE_CS4, NOTE_DS4,

 NOTE_DS4, NOTE_GS3,

 NOTE_G3, NOTE_CS4,

 NOTE_C4, NOTE_FS4, NOTE_F4, NOTE_E3, NOTE_AS4, NOTE_A4,

 NOTE_GS4, NOTE_DS4, NOTE_B3,

 NOTE_AS3, NOTE_A3, NOTE_GS3,

 0, 0, 0

};

int underworld_tempo[] = {

 12, 12, 12, 12,

 12, 12, 6,

 3,

 12, 12, 12, 12,

 12, 12, 6,

 3,

 12, 12, 12, 12,

 12, 12, 6,

 3,

 12, 12, 12, 12,

 12, 12, 6,

 6, 18, 18, 18,

 6, 6,

 6, 6,

 6, 6,

 18, 18, 18, 18, 18, 18,

 10, 10, 10,

 10, 10, 10,

 3, 3, 3

};

int sensorValue;

int outputValue;

#define LED 11

boolean led_state = LOW;

unsigned char counter;

unsigned long temp[21];

unsigned long sub;

bool data_effect = true;

unsigned int heart_rate;

const int max_heartpluse_duty = 2000;

int redPin= 7;

int greenPin = 6;

int bluePin = 5;

void setup() {

 pinMode(9, OUTPUT);

 pinMode(LED, OUTPUT);

 pinMode(12, OUTPUT);

 pinMode(11,  OUTPUT);

 pinMode(10, OUTPUT);

 pinMode(9, OUTPUT);

 pinMode(8, OUTPUT);

 Serial.begin(9600);

 pinMode(3, OUTPUT);

 pinMode(13, OUTPUT);

 Serial.println(“Please ready your chest belt.”);

 delay(5000);

 arrayInit();

 Serial.println(“Heart rate test begin.”);

 attachInterrupt(digitalPinToInterrupt(2), interrupt, RISING);

 pinMode(redPin, OUTPUT);

 pinMode(greenPin, OUTPUT);

 pinMode(bluePin, OUTPUT);

}

//this will run forever

void loop() {

 digitalWrite(LED, led_state);

 if (heart_rate >= 80){

   digitalWrite(12, HIGH);

   }

 if (heart_rate >= 85){

   digitalWrite(11, HIGH);

   }

 if (heart_rate >= 95){

   digitalWrite(10, HIGH);

   }

 if (heart_rate >= 100){

   digitalWrite(9, HIGH);

   }

 if (heart_rate >= 110){

   digitalWrite(8, HIGH);

   }

 if (heart_rate >= 120){

   setColor(255, 0, 0);

   delay(500);

   setColor(0, 255, 0);

   delay(500);

   setColor(0, 0, 255);

   delay(500);

   setColor(255, 255, 255);

   delay(500);

   setColor(170, 0, 255);

   delay(500);

   }

 if (heart_rate >= 140) {

   detachInterrupt(digitalPinToInterrupt(2));

   digitalWrite(13, HIGH);

   delay(3000);

   sing(1);

   sing(1);

   sing(2);

 }

//  if (dataTime.Second = 10000 && heart_rate <= 140){

//    sing(2);

//    }

}

void sum()

{

 if (data_effect)

 {

   heart_rate =  300000/ (temp[5] – temp[0]); //60*20*1000/20_total_time

   Serial.print(“Heart_rate_is:\t”);

   Serial.println(heart_rate);

 }

 data_effect = 1; //sign bit

}

/*Function: Interrupt service routine.Get the sigal from the external interrupt*/

void interrupt()

{

 temp[counter] = millis();

 Serial.println(counter, DEC);

 Serial.println(temp[counter]);

 switch (counter)

 {

   case 0:

     sub = temp[counter] – temp[5];

     Serial.println(sub);

     break;

   default:

     sub = temp[counter] – temp[counter – 1];

     Serial.println(sub);

     break;

 }

 if (sub > max_heartpluse_duty) //set 2 seconds as max heart pluse duty

 {

   data_effect = 0; //sign bit

   counter = 0;

   Serial.println(“Heart rate measure error,test will restart!” );

   arrayInit();

 }

 if (counter == 5 && data_effect)

 {

   counter = 0;

   sum();

 }

 else if (counter != 5 && data_effect)

   counter++;

 else

 {

   counter = 0;

   data_effect = 1;

 }

}

void arrayInit()

{

 for (unsigned char i = 0; i < 5; i ++)

 {

   temp[i] = 0;

 }

 temp[5] = millis();

}

int song = 0;

void sing(int s) {

 // iterate over the notes of the melody:

 song = s;

 if (song == 2) {

   Serial.println(” ‘Underworld Theme'”);

   int size = sizeof(underworld_melody) / sizeof(int);

   for (int thisNote = 0; thisNote < size; thisNote++) {

     // to calculate the note duration, take one second

     // divided by the note type.

     //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.

     int noteDuration = 1000 / underworld_tempo[thisNote];

     buzz(melodyPin, underworld_melody[thisNote], noteDuration);

     // to distinguish the notes, set a minimum time between them.

     // the note’s duration + 30% seems to work well:

     int pauseBetweenNotes = noteDuration * 1.30;

     delay(pauseBetweenNotes);

     // stop the tone playing:

     buzz(melodyPin, 0, noteDuration);

   }

 } else {

   Serial.println(” ‘Mario Theme'”);

   int size = sizeof(melody) / sizeof(int);

   for (int thisNote = 0; thisNote < size; thisNote++) {

     // to calculate the note duration, take one second

     // divided by the note type.

     //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.

     int noteDuration = 1000 / tempo[thisNote];

     buzz(melodyPin, melody[thisNote], noteDuration);

     // to distinguish the notes, set a minimum time between them.

     // the note’s duration + 30% seems to work well:

     int pauseBetweenNotes = noteDuration * 1.30;

     delay(pauseBetweenNotes);

     // stop the tone playing:

     buzz(melodyPin, 0, noteDuration);

   }

 }

}

void buzz(int targetPin, long frequency, long length) {

//  digitalWrite(13, HIGH);

 long delayValue = 1000000 / frequency / 2; // calculate the delay value between transitions

 //// 1 second’s worth of microseconds, divided by the frequency, then split in half since

 //// there are two phases to each cycle

 long numCycles = frequency * length / 1000; // calculate the number of cycles for proper timing

 //// multiply frequency, which is really cycles per second, by the number of seconds to

 //// get the total number of cycles to produce

 for (long i = 0; i < numCycles; i++) { // for the calculated length of time…

   digitalWrite(targetPin, HIGH); // write the buzzer pin high to push out the diaphram

   delayMicroseconds(delayValue); // wait for the calculated delay value

   digitalWrite(targetPin, LOW); // write the buzzer pin low to pull back the diaphram

   delayMicroseconds(delayValue); // wait again or the calculated delay value

 }

//  digitalWrite(13, LOW);

}

void setColor(int redValue, int greenValue, int blueValue) {

 analogWrite(redPin, redValue);

 analogWrite(greenPin, greenValue);

 analogWrite(bluePin, blueValue);

}