arduino-0022

arduino-0022-linux-x64/examples/6.Sensors/ADXL3xx/ADXL3xx.pde

@@ -0,0 +1,64 @@
+
+/*
+ ADXL3xx
+ 
+ Reads an Analog Devices ADXL3xx accelerometer and communicates the
+ acceleration to the computer.  The pins used are designed to be easily
+ compatible with the breakout boards from Sparkfun, available from:
+ http://www.sparkfun.com/commerce/categories.php?c=80
+
+ http://www.arduino.cc/en/Tutorial/ADXL3xx
+
+ The circuit:
+ analog 0: accelerometer self test
+ analog 1: z-axis
+ analog 2: y-axis
+ analog 3: x-axis
+ analog 4: ground
+ analog 5: vcc
+ 
+ created 2 Jul 2008
+ by David A. Mellis
+ modified 4 Sep 2010
+ by Tom Igoe 
+ 
+ This example code is in the public domain.
+
+*/
+
+// these constants describe the pins. They won't change:
+const int groundpin = 18;             // analog input pin 4 -- ground
+const int powerpin = 19;              // analog input pin 5 -- voltage
+const int xpin = A3;                  // x-axis of the accelerometer
+const int ypin = A2;                  // y-axis
+const int zpin = A1;                  // z-axis (only on 3-axis models)
+
+void setup()
+{
+  // initialize the serial communications:
+  Serial.begin(9600);
+  
+  // Provide ground and power by using the analog inputs as normal
+  // digital pins.  This makes it possible to directly connect the
+  // breakout board to the Arduino.  If you use the normal 5V and
+  // GND pins on the Arduino, you can remove these lines.
+  pinMode(groundpin, OUTPUT);
+  pinMode(powerpin, OUTPUT);
+  digitalWrite(groundpin, LOW); 
+  digitalWrite(powerpin, HIGH);
+}
+
+void loop()
+{
+  // print the sensor values:
+  Serial.print(analogRead(xpin));
+  // print a tab between values:
+  Serial.print("\t");
+  Serial.print(analogRead(ypin));
+  // print a tab between values:
+  Serial.print("\t");
+  Serial.print(analogRead(zpin));
+  Serial.println();
+  // delay before next reading:
+  delay(100);
+}

arduino-0022-linux-x64/examples/6.Sensors/Knock/Knock.pde

@@ -0,0 +1,55 @@
+/* Knock Sensor
+  
+   This sketch reads a piezo element to detect a knocking sound. 
+   It reads an analog pin and compares the result to a set threshold. 
+   If the result is greater than the threshold, it writes
+   "knock" to the serial port, and toggles the LED on pin 13.
+  
+   The circuit:
+	* + connection of the piezo attached to analog in 0
+	* - connection of the piezo attached to ground
+	* 1-megohm resistor attached from analog in 0 to ground
+
+   http://www.arduino.cc/en/Tutorial/Knock
+   
+   created 25 Mar 2007
+   by David Cuartielles <http://www.0j0.org>
+   modified 4 Sep 2010
+   by Tom Igoe
+   
+   This example code is in the public domain.
+
+ */
+ 
+
+// these constants won't change:
+const int ledPin = 13;      // led connected to digital pin 13
+const int knockSensor = A0; // the piezo is connected to analog pin 0
+const int threshold = 100;  // threshold value to decide when the detected sound is a knock or not
+
+
+// these variables will change:
+int sensorReading = 0;      // variable to store the value read from the sensor pin
+int ledState = LOW;         // variable used to store the last LED status, to toggle the light
+
+void setup() {
+ pinMode(ledPin, OUTPUT); // declare the ledPin as as OUTPUT
+ Serial.begin(9600);       // use the serial port
+}
+
+void loop() {
+  // read the sensor and store it in the variable sensorReading:
+  sensorReading = analogRead(knockSensor);    
+  
+  // if the sensor reading is greater than the threshold:
+  if (sensorReading >= threshold) {
+    // toggle the status of the ledPin:
+    ledState = !ledState;   
+    // update the LED pin itself:        
+    digitalWrite(ledPin, ledState);
+    // send the string "Knock!" back to the computer, followed by newline
+    Serial.println("Knock!");         
+  }
+  delay(100);  // delay to avoid overloading the serial port buffer
+}
+

arduino-0022-linux-x64/examples/6.Sensors/Memsic2125/Memsic2125.pde

@@ -0,0 +1,63 @@
+/*
+   Memsic2125
+   
+   Read the Memsic 2125 two-axis accelerometer.  Converts the
+   pulses output by the 2125 into milli-g's (1/1000 of earth's
+   gravity) and prints them over the serial connection to the
+   computer.
+   
+   The circuit:
+	* X output of accelerometer to digital pin 2
+	* Y output of accelerometer to digital pin 3
+	* +V of accelerometer to +5V
+	* GND of accelerometer to ground
+  
+   http://www.arduino.cc/en/Tutorial/Memsic2125
+   
+   created 6 Nov 2008
+   by David A. Mellis
+   modified 30 Jun 2009
+   by Tom Igoe
+   
+   This example code is in the public domain.
+
+ */
+
+// these constants won't change:
+const int xPin = 2;		// X output of the accelerometer
+const int yPin = 3;		// Y output of the accelerometer
+
+void setup() {
+  // initialize serial communications:
+  Serial.begin(9600);
+  // initialize the pins connected to the accelerometer
+  // as inputs:
+  pinMode(xPin, INPUT);
+  pinMode(yPin, INPUT);
+}
+
+void loop() {
+  // variables to read the pulse widths:
+  int pulseX, pulseY;
+  // variables to contain the resulting accelerations
+  int accelerationX, accelerationY;
+  
+  // read pulse from x- and y-axes:
+  pulseX = pulseIn(xPin,HIGH);  
+  pulseY = pulseIn(yPin,HIGH);
+  
+  // convert the pulse width into acceleration
+  // accelerationX and accelerationY are in milli-g's: 
+  // earth's gravity is 1000 milli-g's, or 1g.
+  accelerationX = ((pulseX / 10) - 500) * 8;
+  accelerationY = ((pulseY / 10) - 500) * 8;
+
+  // print the acceleration
+  Serial.print(accelerationX);
+  // print a tab character:
+  Serial.print("\t");
+  Serial.print(accelerationY);
+  Serial.println();
+
+  delay(100);
+}

arduino-0022-linux-x64/examples/6.Sensors/Ping/Ping.pde

@@ -0,0 +1,84 @@
+/* Ping))) Sensor
+  
+   This sketch reads a PING))) ultrasonic rangefinder and returns the
+   distance to the closest object in range. To do this, it sends a pulse
+   to the sensor to initiate a reading, then listens for a pulse 
+   to return.  The length of the returning pulse is proportional to 
+   the distance of the object from the sensor.
+     
+   The circuit:
+	* +V connection of the PING))) attached to +5V
+	* GND connection of the PING))) attached to ground
+	* SIG connection of the PING))) attached to digital pin 7
+
+   http://www.arduino.cc/en/Tutorial/Ping
+   
+   created 3 Nov 2008
+   by David A. Mellis
+   modified 30 Jun 2009
+   by Tom Igoe
+ 
+   This example code is in the public domain.
+
+ */
+
+// this constant won't change.  It's the pin number
+// of the sensor's output:
+const int pingPin = 7;
+
+void setup() {
+  // initialize serial communication:
+  Serial.begin(9600);
+}
+
+void loop()
+{
+  // establish variables for duration of the ping, 
+  // and the distance result in inches and centimeters:
+  long duration, inches, cm;
+
+  // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
+  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
+  pinMode(pingPin, OUTPUT);
+  digitalWrite(pingPin, LOW);
+  delayMicroseconds(2);
+  digitalWrite(pingPin, HIGH);
+  delayMicroseconds(5);
+  digitalWrite(pingPin, LOW);
+
+  // The same pin is used to read the signal from the PING))): a HIGH
+  // pulse whose duration is the time (in microseconds) from the sending
+  // of the ping to the reception of its echo off of an object.
+  pinMode(pingPin, INPUT);
+  duration = pulseIn(pingPin, HIGH);
+
+  // convert the time into a distance
+  inches = microsecondsToInches(duration);
+  cm = microsecondsToCentimeters(duration);
+  
+  Serial.print(inches);
+  Serial.print("in, ");
+  Serial.print(cm);
+  Serial.print("cm");
+  Serial.println();
+  
+  delay(100);
+}
+
+long microsecondsToInches(long microseconds)
+{
+  // According to Parallax's datasheet for the PING))), there are
+  // 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
+  // second).  This gives the distance travelled by the ping, outbound
+  // and return, so we divide by 2 to get the distance of the obstacle.
+  // See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
+  return microseconds / 74 / 2;
+}
+
+long microsecondsToCentimeters(long microseconds)
+{
+  // The speed of sound is 340 m/s or 29 microseconds per centimeter.
+  // The ping travels out and back, so to find the distance of the
+  // object we take half of the distance travelled.
+  return microseconds / 29 / 2;
+}