rooty/Arduino
1
0
Fork 0
mirror of https://github.com/arduino/Arduino.git synced 2024-12-01 12:24:14 +01:00
Code Issues Releases Activity

Updated Esplora examples to match the latest of the Esplora repo

Browse Source
This commit is contained in:
Tom Igoe 2012-12-23 11:55:59 -05:00
parent 9ef43accbc
commit fd1055cc5a
14 changed files with 461 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
libraries/Esplora/examples/Beginners/EsploraAccelerometer/EsploraAccelerometer.ino Normal file
View File

@ -0,0 +1,38 @@
/*
Esplora Accelerometer
This sketch shows you how to read the values from the accelerometer.
To see it in action, open the serial monitor and tilt the board. You'll see
the accelerometer values for each axis change when you tilt the board
on that axis.
Created on 22 Dec 2012
by Tom Igoe
This example is in the public domain.
*/
#include <Esplora.h>
void setup()
{
Serial.begin(9600); // initialize serial communications with your computer
}
void loop()
{
int xAxis = Esplora.readAccelerometer(X_AXIS); // read the X axis
int yAxis = Esplora.readAccelerometer(Y_AXIS); // read the Y axis
int zAxis = Esplora.readAccelerometer(Z_AXIS); // read the Z axis
Serial.print("x: "); // print the label for X
Serial.print(xAxis); // print the value for the X axis
Serial.print("\ty: "); // print a tab character, then the label for Y
Serial.print(yAxis); // print the value for the Y axis
Serial.print("\tz: "); // print a tab character, then the label for Z
Serial.println(zAxis); // print the value for the Z axis
delay(500); // wait half a second (500 milliseconds)
}

42
libraries/Esplora/examples/Beginners/EsploraBlink/EsploraBlink.ino Normal file
View File

@ -0,0 +1,42 @@
/*
Esplora Blink
This sketch blinks the Esplora's RGB LED. It goes through
all three primary colors (red, green, blue), then it
combines them for secondary colors(yellow, cyan, magenta), then
it turns on all the colors for white.
For best results cover the LED with a piece of white paper to see the colors.
Created on 22 Dec 2012
by Tom Igoe
This example is in the public domain.
*/
#include <Esplora.h>
void setup() {
// There's nothing to set up for this sketch
}
void loop() {
Esplora.writeRGB(255,0,0); // make the LED red
delay(1000); // wait 1 second
Esplora.writeRGB(0,255,0); // make the LED green
delay(1000); // wait 1 second
Esplora.writeRGB(0,0,255); // make the LED blue
delay(1000); // wait 1 second
Esplora.writeRGB(255,255,0); // make the LED yellow
delay(1000); // wait 1 second
Esplora.writeRGB(0,255,255); // make the LED cyan
delay(1000); // wait 1 second
Esplora.writeRGB(255,0,255); // make the LED magenta
delay(1000); // wait 1 second
Esplora.writeRGB(255,255,255);// make the LED white
delay(1000); // wait 1 second
}

50
libraries/Esplora/examples/Beginners/EsploraJoystickMouse/EsploraJoystickMouse.ino Normal file
View File

@ -0,0 +1,50 @@
/*
Esplora Joystick Mouse
This sketch shows you how to read the joystick and use it to control the movement
of the cursor on your computer. You're making your Esplora into a mouse!
WARNING: this sketch will take over your mouse movement. If you lose control
of your mouse do the following:
1) unplug the Esplora.
2) open the EsploraBlink sketch
3) hold the reset button down while plugging your Esplora back in
4) while holding reset, click "Upload"
5) when you see the message "Done compiling", release the reset button.
This will stop your Esplora from controlling your mouse while you upload a sketch
that doesn't take control of the mouse.
Created on 22 Dec 2012
by Tom Igoe
This example is in the public domain.
*/
#include <Esplora.h>
void setup()
{
Serial.begin(9600); // initialize serial communication with your computer
Mouse.begin(); // take control of the mouse
}
void loop()
{
int xValue = Esplora.readJoystickX(); // read the joystick's X position
int yValue = Esplora.readJoystickY(); // read the joystick's Y position
int button = Esplora.readJoystickSwitch(); // read the joystick pushbutton
Serial.print("Joystick X: "); // print a label for the X value
Serial.print(xValue); // print the X value
Serial.print("\tY: "); // print a tab character and a label for the Y value
Serial.print(yValue); // print the Y value
Serial.print("\tButton: "); // print a tab character and a label for the button
Serial.print(button); // print the button value
int mouseX = map( xValue,-512, 512, 10, -10); // map the X value to a range of movement for the mouse X
int mouseY = map( yValue,-512, 512, -10, 10); // map the Y value to a range of movement for the mouse Y
Mouse.move(mouseX, mouseY, 0); // move the mouse
delay(10); // a short delay before moving again
}

4
libraries/Esplora/examples/EsploraLedShow/EsploraLedShow.ino → libraries/Esplora/examples/Beginners/EsploraLedShow/EsploraLedShow.ino
View File

@ -6,7 +6,7 @@
Created on 22 november 2012
By Enrico Gueli <enrico.gueli@gmail.com>
Modified 24 Nov 2012
Modified 22 Dec 2012
by Tom Igoe
*/
#include <Esplora.h>
@ -24,7 +24,7 @@ void loop() {
// convert the sensor readings to light levels:
byte red = map(xAxis, -512, 512, 0, 255);
byte green = map(xAxis, -512, 512, 0, 255);
byte green = map(yAxis, -512, 512, 0, 255);
byte blue = slider/4;
// print the light levels:

0
libraries/Esplora/examples/EsploraLedShow2/EsploraLedShow2.ino → libraries/Esplora/examples/Beginners/EsploraLedShow2/EsploraLedShow2.ino
View File

91
libraries/Esplora/examples/Beginners/EsploraLightCalibrator/EsploraLightCalibrator.ino Normal file
View File

@ -0,0 +1,91 @@
/*
Esplora Led calibration
This sketch shows you how to read and calibrate the light sensor.
Because light levels vary from one location to another, you need to calibrate the
sensor for each location. To do this, you read the sensor for a few seconds,
and save the highest and lowest readings as maximum and minimum.
Then, when you're using the sensor's reading (for example, to set the brightness
of the LED), you map the sensor's reading to a range between the minimum
and the maximum.
Created on 22 Dec 2012
by Tom Igoe
This example is in the public domain.
*/
#include <Esplora.h>
// variables:
int lightMin = 1023; // minimum sensor value
int lightMax = 0; // maximum sensor value
boolean calibrated = false; // whether the sensor's been calibrated yet
void setup() {
// initialize the serial communication:
Serial.begin(9600);
// print an intial message
Serial.println("To calibrate the light sensor, press and hold Switch 1");
}
void loop() {
// if switch 1 is pressed, go to the calibration function again:
if (Esplora.readButton(1) == LOW) {
calibrate();
}
// read the sensor into a variable:
int light = Esplora.readLightSensor();
// map the light level to a brightness level for the LED
// using the calibration min and max:
int brightness = map(light, lightMin, lightMax, 0, 255);
// limit the brightness to a range from 0 to 255:
brightness = constrain(brightness, 0, 255);
// write the brightness to the blue LED.
Esplora.writeBlue(brightness);
// if the calibration's been done, show the sensor and brightness
// levels in the serial monitor:
if (calibrated == true) {
// print the light sensor levels and the LED levels (to see what's going on):
Serial.print("light sensor level: ");
Serial.print(light);
Serial.print(" blue brightness: ");
Serial.println(brightness);
}
// add a delay to keep the LED from flickering:
delay(10);
}
void calibrate() {
// tell the user what do to using the serial monitor:
Serial.println("While holding switch 1, shine a light on the light sensor, then cover it.");
// calibrate while switch 1 is pressed:
while(Esplora.readButton(1) == LOW) {
// read the sensor value:
int light = Esplora.readLightSensor();
// record the maximum sensor value:
if (light > lightMax) {
lightMax = light;
}
// record the minimum sensor value:
if (light < lightMin) {
lightMin = light;
}
// note that you're calibrated, for future reference:
calibrated = true;
}
}

5
libraries/Esplora/examples/EsploraMusic/EsploraMusic.ino → libraries/Esplora/examples/Beginners/EsploraMusic/EsploraMusic.ino
View File

@ -6,14 +6,15 @@
Created on 22 november 2012
By Enrico Gueli <enrico.gueli@gmail.com>
modified 24 Nov 2012
modified 22 Dec 2012
by Tom Igoe
*/
#include <Esplora.h>
// these are the frequencies for the notes from middle C
// to one octave above middle C:
const int note[] = {
262, // C
277, // C#

41
libraries/Esplora/examples/Beginners/EsploraSoundSensor/EsploraSoundSensor.ino Normal file
View File

@ -0,0 +1,41 @@
/*
Esplora Led calibration
This sketch shows you how to read the microphone sensor. The microphone
will range from 0 (total silence) to 1023 (really loud).
When you're using the sensor's reading (for example, to set the brightness
of the LED), you map the sensor's reading to a range between the minimum
and the maximum.
Created on 22 Dec 2012
by Tom Igoe
This example is in the public domain.
*/
#include <Esplora.h>
void setup() {
// initialize the serial communication:
Serial.begin(9600);
}
void loop() {
// read the sensor into a variable:
int loudness = Esplora.readMicrophone();
// map the sound level to a brightness level for the LED:
int brightness = map(loudness, 0, 1023, 0, 255);
// write the brightness to the green LED:
Esplora.writeGreen(brightness);
// print the microphone levels and the LED levels (to see what's going on):
Serial.print("sound level: ");
Serial.print(loudness);
Serial.print(" Green brightness: ");
Serial.println(brightness);
// add a delay to keep the LED from flickering:
delay(10);
}

37
libraries/Esplora/examples/Beginners/EsploraTemperatureSensor/EsploraTemperatureSensor.ino Normal file
View File

@ -0,0 +1,37 @@
/*
Esplora Temperature Sensor
This sketch shows you how to read the Esplora's temperature sensor
You can read the temperature sensor in Farhenheit or Celsius.
Created on 22 Dec 2012
by Tom Igoe
This example is in the public domain.
*/
#include <Esplora.h>
void setup()
{
Serial.begin(9600); // initialize serial communications with your computer
}
void loop()
{
// read the temperature sensor in Celsius, then Fahrenheit:
int celsius = Esplora.readTemperature(DEGREES_C);
int fahrenheit = Esplora.readTemperature(DEGREES_F);
// print the results:
Serial.print("Temperature is: ");
Serial.print(celsius);
Serial.print(" degrees Celsius, or ");
Serial.print(fahrenheit);
Serial.println(" degrees Fahrenheit.");
Serial.println(" Fahrenheit = (9/5 * Celsius) + 32");
// wait a second before reading again:
delay(1000);
}

94
libraries/Esplora/examples/EsploraRemote/EsploraRemote.ino
View File

@ -1,94 +0,0 @@
/*
Esplora Slave
This sketch allows to test all the Esplora's peripherals.
It is also used with the ProcessingStart sketch (for Processing).
When uploaded, you can open the Serial monitor and write one of
the following commands (without quotes) to get an answer:
"D": prints the current value of all sensors, separated by a comma.
See the dumpInputs() function below to get the meaning of
each value.
"Rxxx"
"Gxxx"
"Bxxx": set the color of the RGB led. For example, write "R255"
to turn on the red to full brightness, "G128" to turn
the green to half brightness, or "G0" to turn off
the green channel.
"Txxxx": play a tone with the buzzer. The number is the
frequency, e.g. "T440" plays the central A note.
Write "T0" to turn off the buzzer.
Created on 22 november 2012
By Enrico Gueli <enrico.gueli@gmail.com>
*/
#include <Esplora.h>
void setup() {
while(!Serial); // needed for Leonardo-based board like Esplora
Serial.begin(9600);
}
void loop() {
if (Serial.available())
parseCommand();
}
/*
* This function reads a character from the serial line and
* decide what to do next. The "what to do" part is given by
* function it calls (e.g. dumpInputs(), setRed() and so on).
*/
void parseCommand() {
char cmd = Serial.read();
switch(cmd) {
case 'D': dumpInputs(); break;
case 'R': setRed(); break;
case 'G': setGreen(); break;
case 'B': setBlue(); break;
case 'T': setTone(); break;
}
}
void dumpInputs() {
/*
* please note: a single row contains two instructions.
* one is to print the sensor value, the other to print the
* comma symbol.
*/
Serial.print(Esplora.readButton(SWITCH_1)); Serial.print(',');
Serial.print(Esplora.readButton(SWITCH_2)); Serial.print(',');
Serial.print(Esplora.readButton(SWITCH_3)); Serial.print(',');
Serial.print(Esplora.readButton(SWITCH_4)); Serial.print(',');
Serial.print(Esplora.readSlider()); Serial.print(',');
Serial.print(Esplora.readLightSensor()); Serial.print(',');
Serial.print(Esplora.readTemperature(DEGREES_C)); Serial.print(',');
Serial.print(Esplora.readMicrophone()); Serial.print(',');
Serial.print(Esplora.readJoystickSwitch()); Serial.print(',');
Serial.print(Esplora.readJoystickX()); Serial.print(',');
Serial.print(Esplora.readJoystickY()); Serial.print(',');
Serial.print(Esplora.readAccelerometer(X_AXIS)); Serial.print(',');
Serial.print(Esplora.readAccelerometer(Y_AXIS)); Serial.print(',');
Serial.print(Esplora.readAccelerometer(Z_AXIS)); Serial.println();
}
void setRed() {
Esplora.writeRed(Serial.parseInt());
}
void setGreen() {
Esplora.writeGreen(Serial.parseInt());
}
void setBlue() {
Esplora.writeBlue(Serial.parseInt());
}
void setTone() {
Esplora.tone(Serial.parseInt());
}

0
libraries/Esplora/examples/EsploraKart/EsploraKart.ino → libraries/Esplora/examples/Experts/EsploraKart/EsploraKart.ino
View File

22
libraries/Esplora/examples/Experts/EsploraPong/EsploraPong.ino Normal file
View File

@ -0,0 +1,22 @@
#include <Esplora.h>
void setup() {
Serial.begin(9600);
}
void loop() {
int slider = Esplora.readSlider();
int resetButton = Esplora.readButton(1);
int serveButton = Esplora.readButton(3);
int switchPlayerButton = Esplora.readButton(4);
Serial.print(slider);
Serial.print(",");
Serial.print(resetButton);
Serial.print(",");
Serial.print(serveButton);
Serial.print(",");
Serial.println(switchPlayerButton);
delay(10);
}

121
libraries/Esplora/examples/Experts/EsploraRemote/EsploraRemote.ino Normal file
View File

@ -0,0 +1,121 @@
/*
Esplora Remote
This sketch allows to test all the Esplora's peripherals.
It is also used with the ProcessingStart sketch (for Processing).
When uploaded, you can open the Serial monitor and write one of
the following commands (without quotes) to get an answer:
"D": prints the current value of all sensors, separated by a comma.
See the dumpInputs() function below to get the meaning of
each value.
"Rxxx"
"Gxxx"
"Bxxx": set the color of the RGB led. For example, write "R255"
to turn on the red to full brightness, "G128" to turn
the green to half brightness, or "G0" to turn off
the green channel.
"Txxxx": play a tone with the buzzer. The number is the
frequency, e.g. "T440" plays the central A note.
Write "T0" to turn off the buzzer.
Created on 22 november 2012
By Enrico Gueli <enrico.gueli@gmail.com>
Modified 22 Dec 2012
by Tom Igoe
*/
#include <Esplora.h>
void setup() {
while(!Serial); // needed for Leonardo-based board like Esplora
Serial.begin(9600);
}
void loop() {
if (Serial.available())
parseCommand();
}
/*
* This function reads a character from the serial line and
* decide what to do next. The "what to do" part is given by
* function it calls (e.g. dumpInputs(), setRed() and so on).
*/
void parseCommand() {
char cmd = Serial.read();
switch(cmd) {
case 'D':
dumpInputs();
break;
case 'R':
setRed();
break;
case 'G':
setGreen();
break;
case 'B':
setBlue();
break;
case 'T':
setTone();
break;
}
}
void dumpInputs() {
/*
* please note: a single row contains two instructions.
* one is to print the sensor value, the other to print the
* comma symbol.
*/
Serial.print(Esplora.readButton(SWITCH_1));
Serial.print(',');
Serial.print(Esplora.readButton(SWITCH_2));
Serial.print(',');
Serial.print(Esplora.readButton(SWITCH_3));
Serial.print(',');
Serial.print(Esplora.readButton(SWITCH_4));
Serial.print(',');
Serial.print(Esplora.readSlider());
Serial.print(',');
Serial.print(Esplora.readLightSensor());
Serial.print(',');
Serial.print(Esplora.readTemperature(DEGREES_C));
Serial.print(',');
Serial.print(Esplora.readMicrophone());
Serial.print(',');
Serial.print(Esplora.readJoystickSwitch());
Serial.print(',');
Serial.print(Esplora.readJoystickX());
Serial.print(',');
Serial.print(Esplora.readJoystickY());
Serial.print(',');
Serial.print(Esplora.readAccelerometer(X_AXIS));
Serial.print(',');
Serial.print(Esplora.readAccelerometer(Y_AXIS));
Serial.print(',');
Serial.print(Esplora.readAccelerometer(Z_AXIS));
Serial.println();
}
void setRed() {
Esplora.writeRed(Serial.parseInt());
}
void setGreen() {
Esplora.writeGreen(Serial.parseInt());
}
void setBlue() {
Esplora.writeBlue(Serial.parseInt());
}
void setTone() {
Esplora.tone(Serial.parseInt());
}

22
libraries/Esplora/examples/EsploraTable/EsploraTable.ino → libraries/Esplora/examples/Experts/EsploraTable/EsploraTable.ino
View File

@ -1,16 +1,17 @@
/*
Esplora Table
Acts like a keyboard that prints sensor
Acts like a keyboard that prints some of its sensors'
data in a table-like text, row by row.
It is a sort of "data-logger".
At startup, it does nothing. It waits for you to open a
spreadsheet (e.g. Google Drive spreadsheet) so it can write
data. By pressing Switch 1, it starts printing the table
At startup, it does nothing. It just waits for you to open a
spreadsheet (e.g. Google Drive spreadsheet) so it can put its
data. Then, by pressing Switch 1, it starts printing the table
headers and the first row of data. It waits a bit, then it
will print another row, and so on.
The amount of time between each row is determined by the slider.
The amount of time between each row is given by the slider.
If put to full left, the sketch will wait 10 seconds; at
full right position, it will wait 5 minutes. An intermediate
position will make the sketch wait for some time in-between.
@ -174,12 +175,17 @@ void logAndPrint() {
}
/**
* Similar to delay(), but allows the program to do something else
* in the meanwhile. In particular, it calls checkSwitchPress().
* Similar to delay(), but allows to do something else
* in the meanwhile. In particular, it calls waitLoop().
* Note 1: it may wait longer than the specified amount, not less;
* Note 2: beware of data synchronization issues, e.g. if the
* activeDelay() function alters some variables used by the
* whileWaiting() function alters some variables used by the
* caller of this function.
*
* I discovered by chance that there's an ongoing discussion about
* adding yield() in the Arduino API:
* http://comments.gmane.org/gmane.comp.hardware.arduino.devel/1381
* The purpose is the same, but for now I'm using this implementation.
*/
void activeDelay(unsigned long amount) {
unsigned long at = millis() + amount;