Interface and application programming

Get Voltage Divider Wired and with right values

Get Arduino with Different AREF value

Note that the resistor will alter the voltage that gets used as the reference because there is an internal 32K resistor on the AREF pin. The two act as a voltage divider, so, for example, 2.5V applied through the resistor will yield 2.5 * 32 / (32 + 5) = ~2.2V at the AREF pin.

32K (internal resistance) / (32K + X) (total resistance)= 0.45 (target voltage) / 5V (total voltage)
      where I needed to solve for X.
32K  / (32K + X) = 0.09
32K = 2880 + 0.09X
29120 = 0.09X
X = 323K  

Get Processing Interfacing with Arduino through Serial Port

void setup()
{
  Serial.begin(9600);
}

void loop() {
  Serial.write(10);    delay(100);     
  Serial.write(100);   delay(100);
  Serial.write(500);   delay(100);
  Serial.write(1000);  delay(100);
}

void draw()
{
  if ( myPort.available() > 0) {  // If data is available,
    val = myPort.read();          // read it and store it in val
  }
  println("Got " + val + " from serial port ");
}

// NOTE: This started with an example by Tom Igoe...

import processing.serial.*;
int lf = 10;    // Linefeed in ASCII
Serial myPort;  // The serial port:
String inString;  // Input string from serial port

void setup() {
  // List all the available serial ports:
  println(Serial.list());
 
  // Open the port you are using at the rate you want:
  myPort = new Serial(this, Serial.list()[5], 9600);
  myPort.bufferUntil(lf);
}

void draw() {
  if (inString.length() > 0) {
     // If I get here, it means there's something in the buffer and something was returned in the serial.event routine
     // println("String Received:" + inString + " - " + millis() + " - Bytes Available: " + myPort.available());
     inString = "";  // resets the buffer value
  }
  delay(100);
}

// This routine will read in whatever is passed to it.  Each thing that's passed will include a character at the front that
// will show what kind of data type it is: 'i' for integer; 's' for string and 'c' for character.
void serialEvent(Serial p) {
  inString = p.readString();
 
  switch(inString.charAt(0)) {
   case 'c':
      print("Character: ");  // Does not execute
      println(inString.charAt(1));
      break;
   case 'i':
      String digitsOnly = inString.substring(1, inString.length()-1);
      int value = int(digitsOnly);
      println("Integer: Digits = " + digitsOnly + " Value: " + str(value));  // Does not execute
      break;
   case 's':
      String stringOnly = inString.substring(1, inString.length()-1);
      println("String: " + stringOnly);  // Does not execute
      break;
    default:             // Default executes if the case labels
      println("Not sure...no data type");   // don't match the switch parameter
      break;
  }
}

/*
The following Wiring/Arduino code runs on both microcontrollers that
were used to send data to this sketch:
*/
void setup()
{
  // start serial port at 9600 bps:
  Serial.begin(9600);
}

void loop() {
  delay(100);
  //Serial.write("c");   Serial.write("M\n");  
  Serial.write("i");   Serial.write("10\n"); 
  Serial.write("s");   Serial.write("Hi Mom\n");
  //Serial.write(500);   delay(100);     Serial.write(0); 
  //Serial.write(1000);  delay(100);     Serial.write(0); 
}

Get Processing to Show Bounceback UI

createShape(), or this particular variation of it, is not available with this renderer.

  size((bouncebackTileSize * 2) + (marginSize * 3) + (tileSpacing * 2), (bouncebackTileSize * 2) + (marginSize * 2) + tileSpacing);

  size((bouncebackTileSize * 2) + (marginSize * 3) + (tileSpacing * 2), (bouncebackTileSize * 2) + (marginSize * 2) + tileSpacing, P2D);

Called directly after setup(), the draw() function continuously executes the lines of code contained inside its block until the program is stopped or noLoop() is called. draw() is called automatically and should never be called explicitly.  It should always be controlled with noLoop(), redraw() and loop(). After noLoop() stops the code in draw() from executing, redraw() causes the code inside draw() to execute once, andloop() will cause the code inside draw() to resume executing continuously. The number of times draw() executes in each second may be controlled with the frameRate()function.

# A fatal error has been detected by the Java Runtime Environment:
#
#  SIGSEGV (0xb) at pc=0x00007fff9533894e, pid=8700, tid=65799
#
# JRE version: Java(TM) SE Runtime Environment (7.0_51-b13) (build 1.7.0_51-b13)
# Java VM: Java HotSpot(TM) 64-Bit Server VM (24.51-b03 mixed mode bsd-amd64 compressed oops)
# Problematic frame:
# C  [libGL.dylib+0x594e]  glUseProgram+0xd

import processing.serial.*;

// The following set the size of the windows and screen elements
int marginSize = 10;
int LEDSize = 15;
int bouncebackTileSize = 200;  // This will represent the size of the bounceback tile.  There will be placed on the screen in a 2x2 matrix
int tileSpacing = 5; // This is the space between tiles

PShape topLeftTile;
PShape bottomLeftTile;
PShape topRightTile;
PShape bottomRightTile;
PShape LEDTile;

// Colors
color clear;
color isTarget;
color wasHit;
color wasMiss;

// This will contain the variables I'll need for the bounceback simulation of hits
int tileActuallyHit = 0; // This will be the tile that the user actually hit
int forceHitWith = 0;    // This will be a value between 0-1023 that will show what hit
int tileToAimFor = 0;    // This will be the tile that the simulator is suggesting the person it.  It will be determined with a random number generator

Serial myPort;  // The serial port:
String inString;  // Input string from serial port
int lf = 10;    // Linefeed in ASCII

void setup() {
  size((bouncebackTileSize * 2) + (marginSize * 3) + (tileSpacing * 2),
       (bouncebackTileSize * 2) + (marginSize * 2) + tileSpacing,
       P2D );
      
  // List all the available serial ports:
  println(Serial.list());
 
  // Open the port you are using at the rate you want:
  myPort = new Serial(this, Serial.list()[5], 9600);
  myPort.bufferUntil(lf);
}

void draw() {
 
  clear = color(#F0F8FF);
  isTarget = color(#FF00FF);
  wasMiss = color(#DC143C);
  wasHit = color(#228B22); 
 
 
  LEDTile = createShape(RECT, (bouncebackTileSize * 2) + (tileSpacing * 2)+ marginSize, marginSize, LEDSize, (bouncebackTileSize * 2) + tileSpacing);
  LEDTile.setFill(clear);
  shape(LEDTile);
  
  bottomRightTile = createShape(RECT, bouncebackTileSize + tileSpacing + marginSize, bouncebackTileSize + tileSpacing + marginSize,  bouncebackTileSize, bouncebackTileSize);
  bottomRightTile.setFill(clear);
  shape(bottomRightTile);
 
  topRightTile = createShape(RECT, bouncebackTileSize + tileSpacing + marginSize, marginSize,  bouncebackTileSize, bouncebackTileSize);
  topRightTile.setFill(clear);
  shape(topRightTile);
 
  bottomLeftTile = createShape(RECT, marginSize, bouncebackTileSize + tileSpacing + marginSize,  bouncebackTileSize, bouncebackTileSize);
  bottomLeftTile.setFill(clear);
  shape(bottomLeftTile);
 
  topLeftTile = createShape(RECT, marginSize, marginSize, bouncebackTileSize, bouncebackTileSize);
  topLeftTile.setFill(clear);
  shape(topLeftTile);
 
  tileToAimFor = int(random(1, 5));
  println("Need to hit: " + tileToAimFor);
 
  // Now that we have something to aim for, we need to set the color
  setTileColor(tileToAimFor, isTarget);
 
  noLoop();
  println("Stopping the looping and waiting for a hit!");
  
 
} // draw()

void processHit(int tileHit, int forceUsed) {
  println("Target: " + tileToAimFor);
  println("Hit:    " + tileHit);
  println("Force:  " + forceUsed);
 
  // When get here, we've receivd the serial communication and we need to take some action
  // to change the UI and tile colors
  if (tileHit == tileToAimFor) {
    setTileColor(tileToAimFor, wasHit);
    println("Hit");
  } // if...hit it
  else {
    setTileColor(tileHit, clear);
    setTileColor(tileToAimFor, wasMiss);
    println("Missed");
  } // else...missed it
} // processHit


void setTileColor(int tileToChange, color colorToSetTo) {
  println("Switching tile " + tileToChange + " to " + colorToSetTo);
 
  switch(tileToChange) {
    case 1:
      topLeftTile.setFill(colorToSetTo);
      shape(topLeftTile);
      break;
    case 2:
      topRightTile.setFill(colorToSetTo);
      shape(topRightTile);
      break;
    case 3:
      bottomLeftTile.setFill(colorToSetTo);
      shape(bottomLeftTile);
      break;
    case 4:
      bottomRightTile.setFill(colorToSetTo);
      shape(bottomRightTile);
      break;
    default:
      println("Houston, we have a problem");
      break;
   }  // switch
  
   redraw();
} // setTileColor


// This routine will read in readings from the arduino that will come in the following format:
// inString.charAt(0) will represent which of the four tiles was hit...1 is top left, 2 is the top right, 3 is the bottom left, 4 is the bottom right
// inString.
void serialEvent(Serial p) {
  inString = p.readString();
 
  tileActuallyHit = int(inString.substring(0, 1));
  println("Hit Tile:       " + tileActuallyHit);
 
  forceHitWith = int(inString.substring(1, inString.length()-1));
  println("Force Hit With: " + forceHitWith);
 
  processHit(tileActuallyHit, forceHitWith);
}