Emily Kramer – Final Project Documentation

Day One

  • Concept presentation: drawing robot that teaches middle school students how to code and build circuits
    • Initial version: students build the robot and circuits, then use Processing to control the robot’s movements
    • Guided by a physical instruction booklet
    • My final project will be an example of what a student could create given the instructions

Day Two

  • First round of feedback (from Cassie)
  • Best suggestion: use Processing to create an interactive instruction booklet rather than a physical booklet and have students deal solely with Arduino; makes a lot of sense and would probably alleviate a lot of confusion
    • Will base the booklet around videos of me putting together components
    • storyboard: 

Day Three

  • Started to make the videos of me putting together the robot itself
    • Materials: cup, markers, cut-up Styrofoam ball, 150 motor from Arduino kit, popsicle sticks
    • decided to have it so that motor will be pre-attached to cup, since kids will probably get frustrated trying to attach it themselves (it does take a lot of time and patience)
  • initial booklet instruction order: welcome screen, materials checklist, robot head, robot body video, robot composite video, breadboard-to-Arduino circuit video, breadboard circuit video, breadboard-to-motor circuit video, coding skeleton video, coding combination video, connection video, finished project video
    • Before each section (robot, circuit and coding), there will be text describing what the student will be doing
    • videos will feature some degree of explanation, especially the ones pertaining to the circuit
    • created a list of materials for each section and wrote down the specific steps for my videos for the first two sections (these will act as “scripts” for the videos)

Day Four

  • Second round of feedback (from Antonius and Tyson)
  • Look into block coding (available on the Arduino website, making the whole project even more accessible) to control the robot
    • Much easier than physically typing out the code and would mitigate frustration due to difficult syntax
    • The mix-and-match element might also encourage students to get creative with their own robot
  • Talk to other people about how best to create the transitions between the instruction videos; use paper prototyping
    • Should beginning materials checklist be words with check boxes or pictures that disappear when you click on them?
    • Should you click the screen or press a key to go to the next video?
  • Suggestions from Tyson: have the forward arrow key press to go to the next step
    • went with the spacebar instead (bigger)
  • Also not sure if I should include multiple examples or just one
    • ultimately had to go with just one example because of time constraints

Day Five

  • Used recitation time to explore the online block coding option ArduBlock
  • Definitely a headache to download
  • Have to decide how to configure the display of my project (whether to keep the instructions on the same computer that the user will use or have it run on a separate computer)
  • figured out that ArduBlock doesn’t work with the latest version of Arduino or the Arduino Uno board; as far as I know, the most recent version available for public download is the 2011 beta version
    • decided that instead of having program instruction videos, I would just have one screen with the actual Arduino code written out so that students could go back and forth between the instructions and their Arduino window as much as they need to, and because the syntax is so specific (they can copy-paste if they really need to)

Day Six

  • first figured out the circuit and Arduino code to control the motor speed with a potentiometer (got help from an Arduino for Dummies page)
  • filmed circuit videos (pretty straightforward)
    • split the circuit process into many videos because it’s a little more complex than the robot, and doing one or two steps per video can help keep things clear
  • started digital instruction booklet
    • first figured out how to create a series of screens where the user can go to the next screen by pressing the spacebar
    • IMG_1405 (video of progress so far)
  • finished booklet
    • inserted videos based on how we learned to do it in class
    • NOTE: at the time of user testing, the videos worked (please take my picture and video as proof), but after toggling with the code a little, they stopped working and I didn’t have time to fix it and film a new demo video. Here are the individual videos:
    • here are screenshots of the instruction booklet’s text screens:

Day Seven

  • user testing!
  • tested on my roommate Kate, because she had no prior experience in coding or electronics
  • I gave her the materials and had her go through the instructions to build her own robot
  • she had to go through twice, but she eventually did it
  • she responded well to the booklet, but had some good suggestions
    • I was most encouraged by the creative response she had; she immediately wanted to start making new things with Arduino, which to me represents the fulfillment of my original goal (to get kids excited about robotics and programming).
    • IMG_1380 (video of her with her final bot)
    • IMG_1381 (video of her feedback)

What I would do differently next time:

  • give myself more time and procrastinate less
  • do more organizational work and planning on the front end
  • do more user tests (preferably with actual kids)
  • try to make the instructions more visually attractive
int screen = 0;
PFont f;
import processing.video.*;
Movie amyMovie;
Movie bmyMovie;
Movie cmyMovie;
Movie dmyMovie;
Movie emyMovie;
Movie fmyMovie;
Movie gmyMovie;
Movie hmyMovie;
Movie imyMovie;
Movie jmyMovie;
Movie kmyMovie;
Movie lmyMovie;
Movie mmyMovie;
Movie nmyMovie;
Movie omyMovie;


void setup() {
  size(1000, 1000);
  f = createFont("Arial",14,true);
  amyMovie = new Movie(this, "IMG_1354.MOV");
  amyMovie.play();
  bmyMovie = new Movie(this, "IMG_1347.MOV");
  bmyMovie.play();
  cmyMovie = new Movie(this, "IMG_1355.MOV");
  cmyMovie.play();
  dmyMovie = new Movie(this, "IMG_1357.MOV");
  dmyMovie.play();
  emyMovie = new Movie(this, "IMG_1361.MOV");
  emyMovie.play();
  fmyMovie = new Movie(this, "IMG_1362.MOV");
  fmyMovie.play();
  gmyMovie = new Movie(this, "IMG_1364.MOV");
  gmyMovie.play();
  hmyMovie = new Movie(this, "IMG_1366.MOV");
  hmyMovie.play();
  imyMovie = new Movie(this, "IMG_1367.MOV");
  imyMovie.play();
  jmyMovie = new Movie(this, "IMG_1368.MOV");
  jmyMovie.play();
  kmyMovie = new Movie(this, "IMG_1369.MOV");
  kmyMovie.play();
  lmyMovie = new Movie(this, "IMG_1370.MOV");
  lmyMovie.play();
  mmyMovie = new Movie(this, "IMG_1371.MOV");
  mmyMovie.play();
  nmyMovie = new Movie(this, "IMG_1372.MOV");
  nmyMovie.play();
  omyMovie = new Movie(this, "IMG_1373.MOV");
  omyMovie.play();
}

void draw() {
  background(#39AEF5);
  textFont(f,14);
  fill(0);
  if(screen == 0) {
  text("Welcome! Today you'll be creating and programming your own drawing robot! This is your video instruction book.",10,100);
  text("In this project, you'll learn the basics of robotics, circuit-building, and coding.",10,150);
  text("Your teacher or acticity leader will hand out kits with all the materials you need.",10,200);
  text("This project will be divided into three sections: the robot, the circuit, and the code.",10,250);
  text("Make sure you pay attention to the checklist at the beginning of each section, so you know what you need to use.",10,300);
  text("Watch each video carefully and repeat the actions you see. After each step, press your spacebar to continue to the next step.",10,350);
  text("Let's begin. Good luck!",10,400);
  }
 if(screen == 1) {
   background(#0AF753);
   textFont(f,14);
   fill(0);
   text("Section One: Building Your Robot", 10, 100);
   text("In this section, you will be building the body of your robot in a few simple steps.",10,150);
   text("You will need:",10,200);
   text("3 markers",10,220);
   text("tape",10,240);
   text("cup with motor attached",10,260);
   text("styrofoam piece",10,280);
   text("popsicle stick",10,300);
 }
 if(screen == 2) {
   if (amyMovie.available()) {
    amyMovie.read();
  }
  image(amyMovie, 0, 0);
 }
 if(screen == 3) {
   if (bmyMovie.available()) {
    bmyMovie.read();
  }
  image(bmyMovie, 0, 0);
 }
 if(screen == 4) {
   if (cmyMovie.available()) {
    cmyMovie.read();
  }
  image(cmyMovie, 0, 0);
 }
 if(screen == 5) {
   if (dmyMovie.available()) {
    dmyMovie.read();
  }
  image(dmyMovie, 0, 0);
 }
  if(screen == 6) {
   background(#F21198);
   textFont(f,14);
   fill(0);
   text("Section Two: Building Your Circuit", 10, 100);
   text("In this section, you will be building the circuit that will power your robot.",10,150);
   text("Pay close attention to where the components are placed so that your circuit works!",10,200);
   text("You will need:",10,250);
   text("F/M wires (2 black, 2 red)",10,300);
   text("M/M wires (4 black, 4 red, 1 green, 1 blue)",10,350);
   text("breadboard, Arduino board and connector cable",10,400);
   text("150 motor, diode and transistor",10,450);
   text("220 ohm resistor, potentiometer and potentiometer knob",10,500);
 }
 if(screen == 7) {
   if (emyMovie.available()) {
    emyMovie.read();
  }
  image(emyMovie, 0, 0);
 }
 if(screen == 8) {
   if (fmyMovie.available()) {
    fmyMovie.read();
  }
  image(fmyMovie, 0, 0);
 }
 if(screen == 9) {
   if (gmyMovie.available()) {
    gmyMovie.read();
  }
  image(gmyMovie, 0, 0);
 }
 if(screen == 10) {
   if (imyMovie.available()) {
    imyMovie.read();
  }
  image(imyMovie, 0, 0);
 }
 if(screen == 11) {
   if (jmyMovie.available()) {
    jmyMovie.read();
  }
  image(jmyMovie, 0, 0);
 }
 if(screen == 12) {
   if (kmyMovie.available()) {
    kmyMovie.read();
  }
  image(kmyMovie, 0, 0);
 }
 if(screen == 13) {
   if (lmyMovie.available()) {
    lmyMovie.read();
  }
  image(lmyMovie, 0, 0);
 }
 if(screen == 14) {
   if (mmyMovie.available()) {
    mmyMovie.read();
  }
  image(mmyMovie, 0, 0);
 }
 if(screen == 15) {
   if (nmyMovie.available()) {
    nmyMovie.read();
  }
  image(nmyMovie, 0, 0);
 }
 if(screen == 16) {
   if (omyMovie.available()) {
    omyMovie.read();
  }
  image(omyMovie, 0, 0);
 }
 if(screen == 17) {
   background(#FCA25C);
   textFont(f,14);
   fill(0);
   text("Section Three: Programming Your Robot",10,100);
   text("In this section, you will be writing the code that will allow you to control your robot!",10,150);
   text("The next screen will show you the code you need to write in your Arduino window.",10,200);
   text("Make sure you write exactly what's on the screen, or the code might not work. Pay attention to capital letters!",10,250);
   text("In places where you see a single quotation mark, be sure to type a double quotation mark instead.",10,300);
   text("Press the spacebar to continue.",10,300);
 }
 if(screen == 18) {
   background(#B043F5);
   textFont(f,14);
   fill(0);
   text("int potentiometerPin = A0;",10,100);
   text("int motorPin = 9;",10,120);
   text("int potentiometerValue = 0;",10,140);
   text("int motorValue = 0;",10,160);
   text("void setup() {",10,180);
   text("Serial.begin(9600);",20,200);
   text("}",10,220);
   text("void loop() {",10,240);
   text("potentiometerValue = analogRead(potentiometerPin);",20,260);
   text("motorValue = map(potentiometerValue, 0, 1025, 0, 255);",20,280);
   text("analogWrite(motorPin, motorValue);",20,300);
   text("Serial.print('potentiometer= ');",20,320);
   text("Serial.print(potentiometerValue);",20,340);
   text("Serial.print('t motor= ');",20,360);
   text("Serial.println(motorValue);",20,380);
   text("delay(2)",20,400);
   text("}",10,420);
 }
 if(screen == 19) {
   background(#39AEF5);
   textFont(f,14);
   fill(0);
   text("Congratulations, you're almost finished!",10,100);
   text("Now, just connect the Arduino to your computer by plugging the connector cable into a USB port.",10,150);
   text("In the Arduino window, click the Upload button to upload the code to the Arduino.",10,200);
   text("If there are problems with the code, Arduino will tell you what they are before it finishes uploading.",10,250);
   text("Once the code uploads, you can control your robot's speed by turning the knob on your potentiometer.",10,300);
   text("Enjoy your robot! You can keep experimenting with code and circuit components to find your favorite way to control the robot.",10,350);
 }
}

void keyPressed() {
  screen = min(screen + 1, 20);
}

Recitation Ten – Emily Kramer

Recitation Ten

  • Attended the soldering workshop because my project doesn’t involve object-oriented programming and I feel confident in my serial communication abilities
  • First exercise: tipping
  • IMG_1158-1 (video of me tipping)
    • We practiced melting solder and cleaning the iron with the metal sponge to remove oxidation
  • Second exercise: soldering wire to electrical tape
    • My first time soldering components together; it wasn’t hard
    • Also learned how to use the wire-stripper
  • Third exercise: soldering two wires together
    • Learned how to use the helping hands
  • Final exercise: soldering a circuit
    • Circuit components: two wires, LED, resistor, coin battery
    • Successfully soldered the components together, but the circuit didn’t work because the instructors handed out the wrong resistors (they were too strong for the battery

Soldering can help me with my final project insofar as I might have to solder wires together for the convenience of having longer connectors and solder components together to create a more attractive presentation. However, since my project is aimed at being low-cost and easy to build, I wouldn’t want soldering to be required to build the final product, so I would have to make that clear in my presentation. Mostly, I went to the soldering workshop because I wanted to take the opportunity to learn something new.

Emily Kramer – Recitation Nine Documentation

Recitation Nine Documentation

Activity

  • Worked with Viktorija Ruzelyte, created the model using TinkerCAD on her laptop
  • Took inspiration from the fun weirdness of Duchamp and Isamu Noguchi
  • Decided to take turns adding elements; she started the body using the egg shape, then I added the nose and mouth, then she added the eyes, etc.
  • Just had fun and didn’t worry about anything making sense or looking good
  • Finished the model in class but had to wait until Monday to print
  • Our design file was easy to convert and was uploaded to the printer via SD card with no problem; Nicholas helped us use the printer
  • Was supposed to take 42 minutes to print
  • IMG_1153 (video of the printer beginning to fabricate our model)
  • When we came back to retrieve the finished product (we both had class), the fellow in the lab said that our piece had broken but didn’t let us in to see it
  • We were supposed to come back later, but every time I came back the lab was locked and I didn’t see any fellows

Reflection

  1. We chose to use PLA filament in 3D printing to fabricate our piece because the creature we created (called “Daddy”) was so abstract and whimsical that we wanted to use a material that was more fun, colorful and unconventional than cardboard or wood. Additionally, 3D printing was going to be the least time-consuming fabrication method, as the entire piece is made of rounded forms, so it just made the most sense.
  2. The new digital fabrication methods we learned will definitely help my final project to be more polished and professional-looking; it might also help me cut down on the time I need to set aside in order to actually create the finished product. The fabrication method I used in my Stupid Pet Trick and midterm projects, namely hand-cutting cardboard, worked fine for what I needed, but the projects themselves definitely weren’t stable, durable, polished, or particularly attractive. Additionally, the intense modelling and iteration process that comes before digital fabrication will force me to slow down and really think about my design in a way that I didn’t have to with my first two projects. With them, if I made a mistake or wanted to change something, I could scrap the cardboard without losing too much labor or losing material, but that method didn’t always yield the best results. For any kind of digital fabrication, I have to be very precise and make sure that the model I fabricate is my final and best one, since I don’t want to waste time or resources.
  3. “The Digital Fabrication Revolution” contextualized this recitation’s activity by providing some background information on current methods of digital fabrication, especially with 3D printing, and by showing the ways in which these methods might evolve and improve in the future. Specifically, the author of the piece focuses on self-reproducing fabrication units, or things that make other things. This piece of context is important because it demonstrates the real-world applications and importance of the technology we are learning to use.
  4. By the year 2149, I imagine that many digital fabrication methods, especially 3D printing, will have evolved far beyond their current capabilities. For example, the variety of materials that can be used in a 3D printer will be endless, so an IMA project then might challenge students to work with many different 3D print mediums to create something. 3D printers will also hopefully have become something that is more affordable and accessible to the general public, like Arduino or Processing; students might even have miniature ones in their personal kits! This would enable them to use the printers all semester long, allowing them to fabricate and innovate at all stages of their learning, on their own time.

Emily Kramer – Final Project Essay

Back in high school, I took three years of engineering classes; while I was never great at programming or putting together complex circuits, I did excel in the workshop. Specifically, I liked to mess around with all the leftover remnants of past projects left in the storage room, and I was best at using unconventional materials to create my own projects. One of my very first projects was a little doodling robot made with a Solo cup, a Styrofoam ball and a popsicle stick. The cup was the body, with three markers attached for the legs that both stabilized the robot and acted as the doodling appendages. I attached a motor to the top of the cup, which was in turn attached to the head (made from the ball and the popsicle stick); the motor was hooked up to an old electric toy train converter, which allowed me to control the speed of the motor and somewhat allowed me to control the robot’s direction. The popsicle stick on top acted as a weight to guide the robot in one direction or another, though I was never able to control its motion as much as I would have liked to. At the engineering department’s project night, I set it down on a sheet of paper and let people create their own doodles. It was a huge hit, especially with kids.

One group in attendance that night was a group from the school board in charge of curriculum and teacher training. They thought that my project’s readily-available materials and simple design would make it a perfect addition to their new sixth-grade science curriculum, so they asked me to come to a training later that month and demonstrate building it to a group of teachers who were going to test the curriculum with their students. To make a long story short, everything was a success, and my design is now being used to give middle schoolers all over my county a fun introduction to engineering and robotics. This means a lot to me, as my district is relatively low-income, and the robot has given teachers and students a cheap and easy way to explore rudimentary robotics, something that they hadn’t been able to do before.

That project’s impact has always stuck with me, and now that I have learned how to use Arduino and Processing, I would like to use them to create a new and improved version of my original doodling robot. My goal is that the new robot will still be a project that teachers can use to introduce their students to robotics, but the use of an Arduino input system and a Processing program to control its movements will also add in a component of elementary circuitry and coding. In keeping with the spirit of the original, the robot’s materials will be low-cost and easy to find; both Arduino and Processing are open-source projects, so they would not make the project too expensive for low-income students and school districts. Eventually, I hope to give the new project to my old school district so that they can use it to keep educating their students at a more advanced level.

Recitation Eight Documentation – Emily Kramer

Part A

  • Step one
    • Circuit components: breadboard, Arduino, M/M jumper cables, H-bridge, stepper motor, external power source
    • Built the circuit according to the dialogue, used the example code and successfully got the motor to rotate
    • IMG_1129 (video of my motor rotating)
  • Step two
    • Just added the potentiometer to the circuit
    • Again, used the example code; added a map(0, 1023, 0, 255) function
      • Went through a few different map values but finally got the code to work
    • I think there was an unintended delay somehow, but the learning fellow and I couldn’t find anything wrong with the code
    • IMG_1133 (video of me controlling my motor’s rotation)
    • Put together the laser-printed pieces according to the pictures (straightforward)

Part B

  • Worked with Lina to make our drawing robot
  • It was easy to connect our circuits, but we initially oriented the laser-printed parts incorrectly, so we had a few bad runs where all we did was move the paper around on the table
  • Fixed the orientation; when we tried it again, the whole robot started shaking because Lina needed to fix a bug in her code
  • We finally got the robot to work correctly!
  • 13 (video of our robot drawing)

Emily Kramer – Midterm Documentation

Midterm Project Documentation

  • Partner: Mostafa Helaley
  • Goal: to create a two-player game like Pong, except with better graphics (maybe) and controlled by motion sensors

Day One

  • Divided up the work: Mostafa will create most of the digital aspects of the game (programming the game output itself on Processing), and I will create most of the physical aspects of the game (programming the Arduino, creating the display, etc.)
    • Important aspect to consider: design of the game must make operation clear; maybe instructions on a start screen?)
  • Made a storyboard
  • Game steps: 1. Start screen with playing instructions 2. Changes to game screen once each player has put their hand over the sensor, with a few seconds’ delay before game begins 3. Players move their hands over the sensors to control the movement of their paddles; higher hand = paddle moves upward 4. Once game is over, screen changes either a scoreboard or a simpler message saying which player won (not sure which one will work yet)
  • Decided to meet again on Wednesday to put everything together

Day Two

  • Built the external circuit and programmed the Arduino
  • Mostafa’s part is almost complete; just needs to fix the bounce function in the game
  • Building the circuit wasn’t a problem, but the initial sensor readings didn’t make any sense (they were all in the 600s no matter where we put our hands); figured out that the sensors’ ranges
  • were too large
    • Switched to sensors with a range of 20-100 cm
  • Was not able to test the sensors with the game program, but the circuit works because I was successfully able to map the sensor values and give them to Mostafa for his code

Day Three

  • Created the physical part of the display
    • Mostafa’s laptop screen will be the game screen, and the keyboard will be hidden under the mounted sensors
    • Classic arcade aesthetic
  • Put everything together: missing a proper start screen, so I wrote out instructions and put them on the physical part of the display
  • 37 (video of Mostafa and I testing our first version of the program)
  • Sometimes the ball glitches when it hits a paddle
    • This happens because the center of the ball lands inside the rectangle, so it takes a while for the program to decide whether the ball is in or out of bounds
  • We weren’t able to code in an end to the game, so users just stop when they want
  • We put in a few fun elements to keep players interested; when the ball hits a paddle, the color scheme changes and the ball gets faster

Day Four

  • User testing
  • IMG_1124(video of me playing against a test user)
  • Main complaints centered on the fact that there’s no real intro to the game, the paddles don’t get faster as the ball gets faster, etc.
    • Many users felt that there was some delay between their hand’s movement and their paddle’s movement
      • This is because our code moves the paddle down when the sensor reads values less than 200 and up when the sensor reads values greater than 200, rather than based on how the values change
    • Other users wish that there was a way for them to make their paddle remain stationary
  • Overall seems to be a good starting point, but not good enough to be a finished product
// Pong game
import processing.serial.*;

String myString = null;
Serial myPort;

int num_of_sensors = 2;
int[] sensorVals;
int bgR,bgG,bgB;


float p1,p2;
Paddle player2, player1;
Ball ball;

void setup(){
  size(1200,800);
  p1 = 350;
  p2 = 350;
  player1 = new Paddle(50, p1);
  player2 = new Paddle(1125, p2);
  ball = new Ball(15);
  bgR = 0;
  bgG = 0;
  bgB = 0;
  
  setupSerial();
  frameRate(30);
}

void draw(){  
  updateSerial();
  //printArray(sensorVals);
  
  
  background(bgR,bgG,bgB);
  
  fill(255);
  player1.show();
  player2.show();
  
  ball.show();
  ball.move();
  ball.checkPlayer2(player2.x,player2.y);
  ball.checkPlayer1(player1.x,player1.y);
  ball.checkBounds();
  ball.score();
  
    if (sensorVals[0] > 100){
     player1.moveDown();
     player1.check();
   }
     
     else {
     player1.check();
     player1.moveUp();
   }
   
     if (sensorVals[1] > 100){
     player2.check();
     player2.moveDown();
   }
     else {
     player2.check();
     player2.moveUp();
   }
}

void setupSerial(){
  printArray(Serial.list());
  myPort = new Serial(this, "COM8", 9600);
  
  myPort.clear();
  
  myString = myPort.readStringUntil(10);
  myString = null;
  
  sensorVals = new int[num_of_sensors];
}

void updateSerial(){
  while(myPort.available() > 0){
     myString = myPort.readStringUntil(10);
     if(myString != null){
        String[] serialInArray = split(trim(myString), ","); 
        if(serialInArray.length == num_of_sensors){
           for(int i = 0; i < serialInArray.length; i++){
              sensorVals[i] = int(serialInArray[i]); 
           }
        }
     }
  }
}
class Ball{
  float r, xPos, yPos;
  float xSpeed, ySpeed;
  int xDirection, yDirection;
  int player1_score;
  int player2_score;
  int red,g,b;
  
  Ball(float radius){
    r = radius;
    xPos = width/2;
    yPos = height/2;
    xSpeed = -6;
    ySpeed = 4;
    xDirection = 1;
    yDirection = -1;
    player1_score = 0;
    player2_score = 0;
    red = 255;
    g = 255;
    b = 255;
  }
  
  void show(){
    //Displays the ball
    fill(red,g,b);
    ellipseMode(RADIUS);
    ellipse(xPos, yPos, r, r);
  }
  
  void move(){
    //Starts the movement of the ball
    xPos += xSpeed * xDirection;
    yPos += ySpeed * yDirection;
  }
  
  void checkPlayer1(float x1, float y1){
   if((xPos <= x1 + r + 20) && (yPos < (y1 - 2) + 154 && yPos > y1)){
      xDirection *= -1; 
      
      if(xDirection == 1){
        xSpeed += 0.5;
      } else{
        xSpeed -= 0.5;
      }
      
      if(yDirection == 1){
        ySpeed += 0.4;
      } else{
        ySpeed -= 0.4;
      }
      red = int(random(0,255));
      g = int(random(0,255));
      b = int(random(0,255));
   }
  }
  
  void checkPlayer2(float x2, float y2){
    //rect(700,y2,width,100);
    if((xPos >= x2 - r) && (yPos < (y2 - 2) + 154 && yPos > y2)){
      xDirection *= -1;
       
      if(xDirection == 1){
        xSpeed += 0.5;
      } else{
        xSpeed -= 0.5;
      }
      
      if(yDirection == 1){
        ySpeed += 0.4;
      } else{
        ySpeed -= 0.4;
      }
      red = int(random(0,255));
      g = int(random(0,255));
      b = int(random(0,255));
    } 
    
    if(yPos > height - r || yPos < r){
      yDirection *= -1;
    }
  }
  
  void checkBounds(){
     if (xPos > 1200){
         xPos = width / 2;
         yPos = height / 2;
         xSpeed *= -1;
         ySpeed *= -1;
         player1_score++;
         bgR = int(random(255));
         bgG = int(random(255));
         bgB = int(random(255));
     }
     else if(xPos < 50){
         xPos = width / 2;
         yPos = height / 2;
         xSpeed *= -1;
         ySpeed *= -1;
         player2_score++;
         bgR = int(random(255));
         bgG = int(random(255));
         bgB = int(random(255));
     }
  }
  
  void score(){
    textSize(50);
    fill(69, 122, 227);
    text(player1_score + " : " + player2_score, 550,50);
  }
}
class Paddle{
  float x,y;
  
  Paddle(float posX, float posY){
   x = posX;
   y = posY;
  }
  
  void show(){
    rect(x,y,20,150);
  }
  
  void moveDown(){
    y += 14;
  }
  
  void moveUp(){
    y -= 14;
  }
  
  void check(){
   if(y >= height - 150){
     y = height - 150 ;
   }
   
   if(y <= 0){
     y = 0;
   }
  }
  
}
Arduino Code;
float val1, val2;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
}

void loop() {
  // put your main code here, to run repeatedly:
  val1 = analogRead(A0) / 4;
  val2 = analogRead(A1) / 4;

  Serial.print(val1);
  Serial.print(",");
  Serial.print(val2);
  Serial.println();
  delay(100);
}

Emily Kramer – Recitation Seven Documentation

This week’s talk was a very interesting introduction to the world of hackerspaces and the start-ups they can hatch. My favorite project was Precious Plastics; not only was the technology involved fascinating, but it has a tangible positive effect on the world, and I like how it gets ordinary citizens involved in the process. I can’t lie and say that now I want to be a part of the hacker community, because I’m not really interested in programming or engineering, and I frankly disagree with the first speaker’s assertion that someday soon everything will be done by artificial intelligence and robots. However, I respect and admire the work that was presented to us during the talk, and I was impressed by their creativity.

Emily Kramer – Recitation Six

Recitation Six Documentation

 

Step One

  • Basic concept: turn on Arduino’s built-in LED when a key is pressed
  • Code based on in-class examples and online tutorials
  • For processing sketch, basically just replaced the mousePressed function with the keyPressed function in the code I created in class with Antonius’ help
  • IMG_1094

Step Two

  • programmed Processing to print values from Arduino potentiometer because I was curious as to what they were
    • components: Arduino and connector cable, potentiometer, jumper cables, breadboard
  • code based on Antonius’ in-class example
  • IMG_1097

Step Three

  1. The possibilities for interactivity using serial communication are endless. In terms of Processing to Arduino, I imagine typing a sequence of keys to turn on different LEDs or using the mouse to control the movement of a servo. In terms of Arduino to Processing, I would focus on the use of sensors, such as creating a thermometer using a temperature sensor that communicates values to Processing, which then prints the temperature on a screen, or using an infrared sensor to control Processing’s background color.
  2. Controlling physical elements through computational media allows the inputs to be more precise and specific, and can make the use of variable inputs easier. Controlling screen-based media with physical elements makes the interaction feel more personal (which is an attractive design feature), and allows for the use of sensors.
  3. This is a very specific example, but Walt Disney World has revamped many of its attraction queues to feature interactive elements during the wait for the ride. Many of these include screens with sensors; the image or animation on the screen changes depending on how the guest moves their hands or arms.

Emily Kramer – Recitation Four

Step One

  • Chose Mark Rothko as my primary inspiration; I like his simple, bold works and the contrast of the colors he uses. The composition of his pieces is minimal and unfussy, but they still draw the viewer in. I am specifically drawn to Black on Maroon and the untitled work done in yellows and whites.
  • The inspiration for my animation comes from the works of Muriel Cooper, and the way her shapes seem to come forward off the screen.

Step Two

  • First things first: just create the still image
    • The goal is to take inspiration from Rothko’s blocky shapes, but to use brighter colors
    • Code based on lecture ten’s in-class examples
    • Functions used: rect( ), int( )
    • Made the first rectangle and messed around with the width and height until I was satisfied with the dimensions (width = 300, height = 200)
    • Duplicated that rectangle farther down on the screen; only had to adjust the y-value; the rectangles echo Black on Maroon
    • Created a thick center line to bring in an element of Rothko’s untitled work; used the rectangle function so that I can color it later
  • Next step: add color!
    • A duochromatic scheme like Rothko’s, but more vibrant
    • Functions used: background( ), fill( ), noStroke( )
    • Background color = #2AF7C2
    • Fill color = #2AB8F7
  • Final step: translation/animation
    • Goal is that shapes will “pop off” the screen and change color
    • Functions used: pushMatrix( ), fill( ), translate( ), rect( ), popMatrix( ), frameRate( ), println( )
    • New fill color = #F77AC7
      • Forgot that I need to add framerate and frame count

Reflection

The image I created in step two is very similar to the inspiration I chose in step one, only it is a more colorful version of the original. Drawing by and and with Processing are similar in that both are outlets of expression via visual images; they are dissimilar in that it is easier to animate those images, and show many layers of images at the same time, using Processing. The value in recreating an existing image in computational media is that it allows almost anyone to take inspiration from that image and rework it to create something entirely new, no matter where they are or what background they have. Because of the differences in color palettes, I do think that my new image evokes a more fun, playful mood than the original image does. If I could create multiple variations of my images, I would want to vary based on color palettes and the directions in which the image’s matrix pops out.

Emily Kramer – Stupid Pet Trick

Goal of the project: create a miniature pair of gladiators; one will swing his “sword” down on the other one when I do a thumbs-down (movement will bring my thumb in range of the infrared sensor, thus activating the circuit).

Circuit

  • Circuit components: Arduino and connector cable, breadboard, short-range infrared sensor, female/male cables, jumper cables
  • Hooked up the sensor to the Arduino based on one of my circuits from recitation three
  • Then hooked up the servo to the Arduino based on an in-class example
    • Had initially begun the project with a motor, but switched to a servo to more easily achieve the chopping motion

Program

  • Code is based on the infrared sensor code that Mostafa and I created in the third recitation and a program I wrote during the in-class activity on how to program the Arduino to move the servo
  • Sensor values: around 4-31 when my thumb is up, around 300-575 when my thumb is down
  • First attempt: just combining the two codes and seeing what happens
    • thing to fix: chopping motion needs to be responsive to the movement of my thumb, not at regular intervals on a loop, so simplified the code to define when (9, HIGH) vs. (9, LOW)
      • This just made the servo jolt back and forth when I did the thumbs-down, so I’m on the right track, but I need the motion to be smoother
      • Modified the code to rotate the servo 90 degrees when (9, HIGH)
      • IT WORKS!!!!!!

Design

  • Will be based around the two gladiator figures (the servo will be attached to the moving one’s sword)
  • Will use cardboard for the sake of convenience
  • Moving gladiator’s sword arm will have to be created and attached separately from the rest of his body
  • First sketched the characters in a regular notebook
  • Secondly rough-cut the cardboard for the figures, stage, and sword to size based on the sketch
    • Decided to cut tabs attached to the bottom of the figures to attach them to the display stage
  • Thirdly glued the stage parts together and made the figures and sword
  • Fourthly attached the figures to the stage and rigged the servo to the sword
    • Tested servo with sword attached to make sure everything still worked correctly; successful
  • Finally rigged the servo to the back of figure one
    • Tested again; successful!
  • IMG_1065