Hi,

First of all I am pretty n00b to Arduino and Processing. 

To make things simple, I would like to make the background change brightness using a digital sensor.

I am using a 3 pin PING Ultrasonic sensor from parallax.com and an Arduino Mega 2560. I cannot seem to receive a steady measurement when the Processing sketch is running as well as Arduino. I also have no idea how to make "things" happen in Processing because "something" digital is happening in Arduino.  

If someone could give me an example of how to make something happen in Processing (e.g. Grow the size of a circle the closer you are) depending on how close something is to the digital sensor in Arduino that would be very helpful. I have found countless analog examples, but I need a digital example.

Thank you in advance for all your help!

PROCESSING:

1. import processing.serial.*;
2. import processing.video.*;
3. Serial myPort;
4. 
   
5. // Size of each cell in the grid, ratio of window size to video size
6. int videoScale = 18;
7. // Number of columns and rows in our system
8. int cols, rows;
9. 
   
10. Capture video;
11. PImage img;
12. void setup() {
13.   println(Serial.list());
14.   myPort = new Serial(this, Serial.list()[1], 9600);
15.   
16.   size(displayWidth, displayHeight);
17.   img = loadImage ("tma_logo_white.png");
18.   smooth();
19. 
    
20. 
    
21.   // Initialize columns and rows
22.   cols = width/videoScale;
23.   rows = height/videoScale;
24.   video = new Capture(this, width, height);
25.   video.start();
26. }
27. 
    
28. void draw() {
29.   // Read image from the camera
30.   if (video.available()) {
31.     video.read();
32.   }
33.   video.loadPixels();
34.   
35.   background(mouseX, mouseY, pingValue);
36.   image (img, 83, 9);
37. 
    
38.   // Begin loop for columns
39.   for (int i = 5; i+5 < cols; i++) {
40.     // Begin loop for rows
41.     for (int j = 4; j+4 < rows; j++) {
42. 
    
43.       // Where are we, pixel-wise?
44.       int x = i*videoScale;
45.       int y = j*videoScale;
46.       // Looking up the appropriate color in the pixel array
47.       color c = video.pixels[x + y*video.width];
48.       fill(c);
49.       noStroke();
50. 
    
51.       if (mouseY < y) {
52.         ellipse(x, y, videoScale, videoScale);
53.       }
54.       else {
55.         rect(x-8, y, videoScale-1, videoScale-1);
56.       }
57.     }
58.   }
59. }
60. 
    
61. void serialEvent (Serial myPort) {
62.   println(digitalRead(pingValue));
63. }

ARDUINO:

1. #include <NewPing.h>
2. 
   
3. const int pingPin = 8;
4. int distance = 0;
5. int pingValue;
6. 
   
7. void setup()
8. {
9.   // start serial port at 9600 bps:
10.   Serial.begin(9600);
11. }
12. 
    
13. void loop() {
14. {
15.   //while(Serial.available()>0) Serial.read();
16.   // establish variables for duration of the ping, 
17.   // and the distance result in inches and centimeters:
18.   long duration, inches, cm;
19.   
20.   pinMode(pingPin, OUTPUT);
21.   digitalWrite(pingPin, LOW);
22.   delayMicroseconds(2);
23.   digitalWrite(pingPin, HIGH);
24.   delayMicroseconds(5);
25.   digitalWrite(pingPin, LOW);
26.   
27.   pinMode(8, INPUT);   // digital sensor is on digital pin 8
28.   duration = pulseIn(pingPin, HIGH);
29.   distance = (duration/2) / 29.1;
30. 
    
31.   // convert the time into a distance
32.   inches = microsecondsToInches(duration);
33.   cm = microsecondsToCentimeters(duration);
34.   
35.   Serial.write(pingValue);
36.   Serial.print(inches);
37.   Serial.print("in, ");
38. //  Serial.print(cm);
39. //  Serial.print("cm");
40.   Serial.println();
41.   
42.   delay(100);
43. }
44. }
45. 
    
46. long microsecondsToInches(long microseconds)
47. {
48.   // According to Parallax's datasheet for the PING))), there are
49.   // 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
50.   // second).  This gives the distance travelled by the ping, outbound
51.   // and return, so we divide by 2 to get the distance of the obstacle.
52.   // See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
53.   return microseconds / 74 / 2;
54. }
55. 
    
56. long microsecondsToCentimeters(long microseconds)
57. {
58.   // The speed of sound is 340 m/s or 29 microseconds per centimeter.
59.   // The ping travels out and back, so to find the distance of the
60.   // object we take half of the distance travelled.
61.   return microseconds / 29 / 2;
62. }