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

Removing Esplora library from this repo. Downloaded at build time

Browse Source
This commit is contained in:
Federico Fissore 2015-09-24 11:33:16 +02:00
parent 737faaaba5
commit 0b1f5249d4
20 changed files with 2 additions and 1419 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
build/Esplora-1.0.4.zip.sha Normal file
View File

@ -0,0 +1 @@
9b2ab86d0c7d0436febfe2026c7a42607d29c721

1
build/build.xml
View File

@ -193,6 +193,7 @@
<download-library name="RobotIRremote" version="1.0.2"/>
<download-library name="SpacebrewYun" version="1.0.0"/>
<download-library name="Temboo" version="1.1.3" githubuser="temboo"/>
<download-library name="Esplora" version="1.0.4"/>
</target>
<macrodef name="download-library">

24
libraries/Esplora/README.adoc
View File

@ -1,24 +0,0 @@
= Esplora Library for Arduino =
The library offers easy access to the data from the onboard Esplora's sensors, and provides the ability to change the state of the outputs.
For more information about this library please visit us at
http://www.arduino.cc/en/Reference/EsploraLibrary
== License ==
Copyright (c) 2012 Arduino LLC. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

36
libraries/Esplora/examples/Beginners/EsploraAccelerometer/EsploraAccelerometer.ino
View File

@ -1,36 +0,0 @@
/*
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
View File

@ -1,42 +0,0 @@
/*
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
}

58
libraries/Esplora/examples/Beginners/EsploraJoystickMouse/EsploraJoystickMouse.ino
View File

@ -1,58 +0,0 @@
/*
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
Updated 8 March 2014
by Scott Fitzgerald
http://www.arduino.cc/en/Reference/EsploraReadJoystickSwitch
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
if (button == 0) { // if the joystick button is pressed
Mouse.press(); // send a mouse click
} else {
Mouse.release(); // if it's not pressed, release the mouse button
}
delay(10); // a short delay before moving again
}

42
libraries/Esplora/examples/Beginners/EsploraLedShow/EsploraLedShow.ino
View File

@ -1,42 +0,0 @@
/*
Esplora LED Show
Makes the RGB LED bright and glow as the joystick or the
slider are moved.
Created on 22 november 2012
By Enrico Gueli <enrico.gueli@gmail.com>
Modified 22 Dec 2012
by Tom Igoe
*/
#include <Esplora.h>
void setup() {
// initialize the serial communication:
Serial.begin(9600);
}
void loop() {
// read the sensors into variables:
int xAxis = Esplora.readJoystickX();
int yAxis = Esplora.readJoystickY();
int slider = Esplora.readSlider();
// convert the sensor readings to light levels:
byte red = map(xAxis, -512, 512, 0, 255);
byte green = map(yAxis, -512, 512, 0, 255);
byte blue = slider / 4;
// print the light levels:
Serial.print(red);
Serial.print(' ');
Serial.print(green);
Serial.print(' ');
Serial.println(blue);
// write the light levels to the LED.
Esplora.writeRGB(red, green, blue);
// add a delay to keep the LED from flickering:
delay(10);
}

55
libraries/Esplora/examples/Beginners/EsploraLedShow2/EsploraLedShow2.ino
View File

@ -1,55 +0,0 @@
/*
Esplora Led/Microphone
This simple sketch reads the microphone, light sensor, and slider.
Then it uses those readings to set the brightness of red, green and blue
channels of the RGB LED. The red channel will change with the loudness
"heared" by the microphone, the green channel changes as the
amount of light in the room and the blue channel will change
with the position of the slider.
Created on 22 november 2012
By Enrico Gueli <enrico.gueli@gmail.com>
Modified 24 Nov 2012
by Tom Igoe
*/
#include <Esplora.h>
void setup() {
// initialize the serial communication:
Serial.begin(9600);
}
int lowLight = 400; // the light sensor reading when it's covered
int highLight = 1023; // the maximum light sensor reading
int minGreen = 0; // minimum brightness of the green LED
int maxGreen = 100; // maximum brightness of the green LED
void loop() {
// read the sensors into variables:
int mic = Esplora.readMicrophone();
int light = Esplora.readLightSensor();
int slider = Esplora.readSlider();
// convert the sensor readings to light levels:
byte red = constrain(mic, 0, 255);
byte green = constrain(
map(light, lowLight, highLight, minGreen, maxGreen),
0, 255);
byte blue = slider / 4;
// print the light levels (to see what's going on):
Serial.print(red);
Serial.print(' ');
Serial.print(green);
Serial.print(' ');
Serial.println(blue);
// write the light levels to the LED.
// note that the green value is always 0:
Esplora.writeRGB(red, green, blue);
// add a delay to keep the LED from flickering:
delay(10);
}

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

@ -1,91 +0,0 @@
/*
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;
}
}

52
libraries/Esplora/examples/Beginners/EsploraMusic/EsploraMusic.ino
View File

@ -1,52 +0,0 @@
/*
Esplora Music
This sketch turns the Esplora in a simple musical instrument.
Press the Switch 1 and move the slider to see how it works.
Created on 22 november 2012
By Enrico Gueli <enrico.gueli@gmail.com>
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#
294, // D
311, // D#
330, // E
349, // F
370, // F#
392, // G
415, // G#
440, // A
466, // A#
494, // B
523 // C next octave
};
void setup() {
}
void loop() {
// read the button labeled SWITCH_DOWN. If it's low,
// then play a note:
if (Esplora.readButton(SWITCH_DOWN) == LOW) {
int slider = Esplora.readSlider();
// use map() to map the slider's range to the
// range of notes you have:
byte thisNote = map(slider, 0, 1023, 0, 13);
// play the note corresponding to the slider's position:
Esplora.tone(note[thisNote]);
} else {
// if the button isn't pressed, turn the note off:
Esplora.noTone();
}
}

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

@ -1,41 +0,0 @@
/*
Esplora Sound Sensor
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);
}

35
libraries/Esplora/examples/Beginners/EsploraTemperatureSensor/EsploraTemperatureSensor.ino
View File

@ -1,35 +0,0 @@
/*
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);
}

124
libraries/Esplora/examples/Experts/EsploraKart/EsploraKart.ino
View File

@ -1,124 +0,0 @@
/*
Esplora Kart
This sketch turns the Esplora into a PC game pad.
It uses the both the analog joystick and the four switches.
By moving the joystick in a direction or by pressing a switch,
the PC will "see" that a key is pressed. If the PC is running
a game that has keyboard input, the Esplora can control it.
The default configuration is suitable for SuperTuxKart, an
open-source racing game. It can be downloaded from
http://supertuxkart.sourceforge.net/ .
Created on 22 november 2012
By Enrico Gueli <enrico.gueli@gmail.com>
*/
#include <Esplora.h>
/*
You're going to handle eight different buttons. You'll use arrays,
which are ordered lists of variables with a fixed size. Each array
has an index (counting from 0) to keep track of the position
you're reading in the array, and each position can contain a number.
This code uses three different arrays: one for the buttons you'll read;
a second to hold the current states of those buttons; and a third to hold
the keystrokes associated with each button.
*/
/*
This array holds the last sensed state of each of the buttons
you're reading.
Later in the code, you'll read the button states, and compare them
to the previous states that are stored in this array. If the two
states are different, it means that the button was either
pressed or released.
*/
boolean buttonStates[8];
/*
This array holds the names of the buttons being read.
Later in the sketch, you'll use these names with
the method Esplora.readButton(x), where x
is one of these buttons.
*/
const byte buttons[] = {
JOYSTICK_DOWN,
JOYSTICK_LEFT,
JOYSTICK_UP,
JOYSTICK_RIGHT,
SWITCH_RIGHT, // fire
SWITCH_LEFT, // bend
SWITCH_UP, // nitro
SWITCH_DOWN, // look back
};
/*
This array tells what keystroke to send to the PC when a
button is pressed.
If you look at this array and the above one, you can see that
the "cursor down" keystroke is sent when the joystick is moved
down, the "cursor up" keystroke when the joystick is moved up
and so on.
*/
const char keystrokes[] = {
KEY_DOWN_ARROW,
KEY_LEFT_ARROW,
KEY_UP_ARROW,
KEY_RIGHT_ARROW,
' ',
'V',
'N',
'B'
};
/*
This is code is run only at startup, to initialize the
virtual USB keyboard.
*/
void setup() {
Keyboard.begin();
}
/*
After setup() is finished, this code is run continuously.
Here we continuously check if something happened with the
buttons.
*/
void loop() {
// Iterate through all the buttons:
for (byte thisButton = 0; thisButton < 8; thisButton++) {
boolean lastState = buttonStates[thisButton];
boolean newState = Esplora.readButton(buttons[thisButton]);
if (lastState != newState) { // Something changed!
/*
The Keyboard library allows you to "press" and "release" the
keys as two distinct actions. These actions can be
linked to the buttons we're handling.
*/
if (newState == PRESSED) {
Keyboard.press(keystrokes[thisButton]);
} else if (newState == RELEASED) {
Keyboard.release(keystrokes[thisButton]);
}
}
// Store the new button state, so you can sense a difference later:
buttonStates[thisButton] = newState;
}
/*
Wait a little bit (50ms) between a check and another.
When a mechanical switch is pressed or released, the
contacts may bounce very rapidly. If the check is done too
fast, these bounces may be confused as multiple presses and
may lead to unexpected behaviour.
*/
delay(50);
}

44
libraries/Esplora/examples/Experts/EsploraPong/EsploraPong.ino
View File

@ -1,44 +0,0 @@
/*
Esplora Pong
This sketch connects serially to a Processing sketch to control a Pong game.
It sends the position of the slider and the states of three pushbuttons to the
Processing sketch serially, separated by commas. The Processing sketch uses that
data to control the graphics in the sketch.
The slider sets a paddle's height
Switch 1 is resets the game
Switch 2 resets the ball to the center
Switch 3 reverses the players
You can play this game with one or two Esploras.
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
}
void loop() {
// read the slider and three of the buttons
int slider = Esplora.readSlider();
int resetButton = Esplora.readButton(SWITCH_1);
int serveButton = Esplora.readButton(SWITCH_3);
int switchPlayerButton = Esplora.readButton(SWITCH_4);
Serial.print(slider); // print the slider value
Serial.print(","); // add a comma
Serial.print(resetButton); // print the reset button value
Serial.print(","); // add another comma
Serial.print(serveButton); // print the serve button value
Serial.print(","); // add another comma
Serial.println(switchPlayerButton); // print the last button with a newline
delay(10); // delay before sending the next set
}

117
libraries/Esplora/examples/Experts/EsploraRemote/EsploraRemote.ino
View File

@ -1,117 +0,0 @@
/*
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 23 Dec 2012
by Tom Igoe
*/
#include <Esplora.h>
void setup() {
Serial.begin(9600);
while (!Serial); // needed for native USB port only
}
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() {
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());
}

216
libraries/Esplora/examples/Experts/EsploraTable/EsploraTable.ino
View File

@ -1,216 +0,0 @@
/*
Esplora Table
Acts like a keyboard that prints sensor
data in a table-like text, row by row.
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
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.
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.
Clicking the Switch 1 at any time will stop the logging.
The color LED shows what the sketch is doing:
blue = idle, waiting for you to press Switch 1 to start logging
green = active; will print soon
red = printing data to the PC
Created on 22 november 2012
By Enrico Gueli <enrico.gueli@gmail.com>
modified 24 Nov 2012
by Tom Igoe
*/
#include <Esplora.h>
/*
* this variable tells if the data-logging is currently active.
*/
boolean active = false;
/*
* this variable holds the time in the future when the sketch
* will "sample" the data (sampling is the act of reading some
* input at a known time). This variable is checked continuously
* against millis() to know when it's time to sample.
*/
unsigned long nextSampleAt = 0;
/*
* This variable just holds the millis() value at the time the
* logging was activated. This is needed to enter the correct
* value in the "Time" column in the printed table.
*/
unsigned long startedAt = 0;
/*
* when the "active" variable is set to true, the same is done
* with this variable. This is needed because the code that does
* the "just-after-activation" stuff is run some time later than
* the code that says "be active now".
*/
boolean justActivated = false;
/*
* this variable holds the last sensed status of the switch press
* button. If the code sees a difference between the value of
* this variable and the current status of the switch, it means
* that the button was either pressed or released.
*/
boolean lastStartBtn = HIGH;
/*
* Initialization code. The virtual USB keyboard must be
* initialized; the Serial class is needed just for debugging.
*/
void setup() {
Keyboard.begin();
Serial.begin(9600);
}
/*
* This code is run continuously.
*/
void loop() {
/*
* note: we don't use Arduino's delay() here, because we can't
* normally do anything while delaying. Our own version lets us
* check for button presses often enough to not miss any event.
*/
activeDelay(50);
/*
* the justActivated variable may be set to true in the
* checkSwitchPress() function. Here we check its status to
* print the table headers and configure what's needed to.
*/
if (justActivated == true) {
justActivated = false; // do this just once
printHeaders();
// do next sampling ASAP
nextSampleAt = startedAt = millis();
}
if (active == true) {
if (nextSampleAt < millis()) {
// it's time to sample!
int slider = Esplora.readSlider();
// the row below maps the slider position to a range between
// 10 and 290 seconds.
int sampleInterval = map(slider, 0, 1023, 10, 290);
nextSampleAt = millis() + sampleInterval * 1000;
logAndPrint();
}
// let the RGB led blink green once per second, for 200ms.
unsigned int ms = millis() % 1000;
if (ms < 200) {
Esplora.writeGreen(50);
} else {
Esplora.writeGreen(0);
}
Esplora.writeBlue(0);
} else
// while not active, keep a reassuring blue color coming
// from the Esplora...
{
Esplora.writeBlue(20);
}
}
/*
* Print the table headers.
*/
void printHeaders() {
Keyboard.print("Time");
Keyboard.write(KEY_TAB);
activeDelay(300); // Some spreadsheets are slow, e.g. Google
// Drive that wants to save every edit.
Keyboard.print("Accel X");
Keyboard.write(KEY_TAB);
activeDelay(300);
Keyboard.print("Accel Y");
Keyboard.write(KEY_TAB);
activeDelay(300);
Keyboard.print("Accel Z");
Keyboard.println();
activeDelay(300);
}
void logAndPrint() {
// do all the samplings at once, because keystrokes have delays
unsigned long timeSecs = (millis() - startedAt) / 1000;
int xAxis = Esplora.readAccelerometer(X_AXIS);
int yAxis = Esplora.readAccelerometer(Y_AXIS);
int zAxis = Esplora.readAccelerometer(Z_AXIS);
Esplora.writeRed(100);
Keyboard.print(timeSecs);
Keyboard.write(KEY_TAB);
activeDelay(300);
Keyboard.print(xAxis);
Keyboard.write(KEY_TAB);
activeDelay(300);
Keyboard.print(yAxis);
Keyboard.write(KEY_TAB);
activeDelay(300);
Keyboard.print(zAxis);
Keyboard.println();
activeDelay(300);
Keyboard.write(KEY_HOME);
Esplora.writeRed(0);
}
/**
* Similar to delay(), but allows the program to do something else
* in the meanwhile. In particular, it calls checkSwitchPress().
* 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
* caller of this function.
*/
void activeDelay(unsigned long amount) {
unsigned long at = millis() + amount;
while (millis() < at) {
checkSwitchPress();
}
}
/*
* This function reads the status of the switch; if it sees that
* it was pressed, toggles the status of the "active" variable.
* If it's set to true, also the justActivated variable is set to
* true, so the loop() function above can do the right things.
* This function should be called as often as possible and do as
* little as possible, because it can be called while another
* function is running.
*/
void checkSwitchPress() {
boolean startBtn = Esplora.readButton(SWITCH_DOWN);
if (startBtn != lastStartBtn) {
if (startBtn == HIGH) { // button released
active = !active;
if (active) {
justActivated = true;
}
}
lastStartBtn = startBtn;
}
}

72
libraries/Esplora/keywords.txt
View File

@ -1,72 +0,0 @@
#######################################
# Syntax Coloring Map For Esplora
#######################################
# Class
#######################################
Esplora KEYWORD1 EsploraLibrary
#######################################
# Methods and Functions
#######################################
begin KEYWORD2
readSlider KEYWORD2
readLightSensor KEYWORD2
readTemperature KEYWORD2
readMicrophone KEYWORD2
readJoystickSwitch KEYWORD2
readJoystickButton KEYWORD2
readJoystickX KEYWORD2
readJoystickY KEYWORD2
readAccelerometer KEYWORD2
readButton KEYWORD2
writeRGB KEYWORD2
writeRed KEYWORD2
writeGreen KEYWORD2
writeBlue KEYWORD2
readRed KEYWORD2
readGreen KEYWORD2
readBlue KEYWORD2
readTinkerkitInput KEYWORD2
readTinkerkitInputA KEYWORD2
readTinkerkitInputB KEYWORD2
tone KEYWORD2
noTone KEYWORD2
#######################################
# Constants
#######################################
JOYSTICK_BASE LITERAL1
MAX_CHANNELS LITERAL1
CH_SWITCH_1 LITERAL1
CH_SWITCH_2 LITERAL1
CH_SWITCH_3 LITERAL1
CH_SWITCH_4 LITERAL1
CH_SLIDER LITERAL1
CH_LIGHT LITERAL1
CH_TEMPERATURE LITERAL1
CH_MIC LITERAL1
CH_JOYSTICK_SW LITERAL1
CH_JOYSTICK_X LITERAL1
CH_JOYSTICK_Y LITERAL1
SWITCH_1 LITERAL1
SWITCH_2 LITERAL1
SWITCH_3 LITERAL1
SWITCH_4 LITERAL1
SWITCH_DOWN LITERAL1
SWITCH_LEFT LITERAL1
SWITCH_UP LITERAL1
SWITCH_RIGHT LITERAL1
JOYSTICK_DOWN LITERAL1
JOYSTICK_LEFT LITERAL1
JOYSTICK_UP LITERAL1
PRESSED LITERAL1
RELEASED LITERAL1
DEGREES_C LITERAL1
DEGREES_F LITERAL1
X_AXIS LITERAL1
Y_AXIS LITERAL1
Z_AXIS LITERAL1

9
libraries/Esplora/library.properties
View File

@ -1,9 +0,0 @@
name=Esplora
version=1.0.4
author=Arduino
maintainer=Arduino <info@arduino.cc>
sentence=Grants easy access to the various sensors and actuators of the Esplora. For Arduino Esplora only.
paragraph=The sensors available on the board are:2-Axis analog joystick with center push-button,4 push-buttons,microphone, light sensor, temperature sensor, 3-axis accelerometer, 2 TinkerKit input connectors.</br>The actuators available on the board are: bright RGB LED, piezo buzzer, 2 TinkerKit output connectors.
category=Device Control
url=http://www.arduino.cc/en/Reference/EsploraLibrary
architectures=avr

184
libraries/Esplora/src/Esplora.cpp
View File

@ -1,184 +0,0 @@
/*
Esplora.cpp - Arduino Esplora board library
Written by Enrico Gueli
Copyright (c) 2012 Arduino LLC. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "Esplora.h"
_Esplora Esplora;
/*
* The following constants tell, for each accelerometer
* axis, which values are returned when the axis measures
* zero acceleration.
*/
const int ACCEL_ZERO_X = 320;
const int ACCEL_ZERO_Y = 330;
const int ACCEL_ZERO_Z = 310;
const byte MUX_ADDR_PINS[] = { A0, A1, A2, A3 };
const byte MUX_COM_PIN = A4;
const int JOYSTICK_DEAD_ZONE = 100;
const byte RED_PIN = 5;
const byte BLUE_PIN = 9;
const byte GREEN_PIN = 10;
const byte BUZZER_PIN = 6;
// non-multiplexer Esplora pins:
// Accelerometer: x-A5, y-A11, z-A6
// External outputs: D3, D11
// Buzzer: D6
// RGB Led: red-D5, green-D10, blue-D9
// Led 13: D13
const byte ACCEL_X_PIN = A5;
const byte ACCEL_Y_PIN = A11;
const byte ACCEL_Z_PIN = A6;
const byte LED_PIN = 13;
_Esplora::_Esplora() {
for (byte p=0; p<4; p++) {
pinMode(MUX_ADDR_PINS[p], OUTPUT);
}
pinMode(RED_PIN, OUTPUT);
pinMode(GREEN_PIN, OUTPUT);
pinMode(BLUE_PIN, OUTPUT);
}
unsigned int _Esplora::readChannel(byte channel) {
digitalWrite(MUX_ADDR_PINS[0], (channel & 1) ? HIGH : LOW);
digitalWrite(MUX_ADDR_PINS[1], (channel & 2) ? HIGH : LOW);
digitalWrite(MUX_ADDR_PINS[2], (channel & 4) ? HIGH : LOW);
digitalWrite(MUX_ADDR_PINS[3], (channel & 8) ? HIGH : LOW);
// workaround to cope with lack of pullup resistor on joystick switch
if (channel == CH_JOYSTICK_SW) {
pinMode(MUX_COM_PIN, INPUT_PULLUP);
unsigned int joystickSwitchState = (digitalRead(MUX_COM_PIN) == HIGH) ? 1023 : 0;
digitalWrite(MUX_COM_PIN, LOW);
return joystickSwitchState;
}
else
return analogRead(MUX_COM_PIN);
}
boolean _Esplora::joyLowHalf(byte joyCh) {
return (readChannel(joyCh) < 512 - JOYSTICK_DEAD_ZONE)
? LOW : HIGH;
}
boolean _Esplora::joyHighHalf(byte joyCh) {
return (readChannel(joyCh) > 512 + JOYSTICK_DEAD_ZONE)
? LOW : HIGH;
}
boolean _Esplora::readButton(byte ch) {
if (ch >= SWITCH_1 && ch <= SWITCH_4) {
ch--;
}
switch(ch) {
case JOYSTICK_RIGHT:
return joyLowHalf(CH_JOYSTICK_X);
case JOYSTICK_LEFT:
return joyHighHalf(CH_JOYSTICK_X);
case JOYSTICK_UP:
return joyLowHalf(CH_JOYSTICK_Y);
case JOYSTICK_DOWN:
return joyHighHalf(CH_JOYSTICK_Y);
}
unsigned int val = readChannel(ch);
return (val > 512) ? HIGH : LOW;
}
boolean _Esplora::readJoystickButton() {
if (readChannel(CH_JOYSTICK_SW) == 1023) {
return HIGH;
} else if (readChannel(CH_JOYSTICK_SW) == 0) {
return LOW;
}
}
void _Esplora::writeRGB(byte r, byte g, byte b) {
writeRed(r);
writeGreen(g);
writeBlue(b);
}
#define RGB_FUNC(name, pin, lastVar) \
void _Esplora::write##name(byte val) { \
if (val == lastVar) \
return; \
analogWrite(pin, val); \
lastVar = val; \
delay(5); \
} \
\
byte _Esplora::read##name() { \
return lastVar; \
}
RGB_FUNC(Red, RED_PIN, lastRed)
RGB_FUNC(Green, GREEN_PIN, lastGreen)
RGB_FUNC(Blue, BLUE_PIN, lastBlue)
void _Esplora::tone(unsigned int freq) {
if (freq > 0)
::tone(BUZZER_PIN, freq);
else
::noTone(BUZZER_PIN);
}
void _Esplora::tone(unsigned int freq, unsigned long duration) {
if (freq > 0)
::tone(BUZZER_PIN, freq, duration);
else
::noTone(BUZZER_PIN);
}
void _Esplora::noTone() {
::noTone(BUZZER_PIN);
}
int _Esplora::readTemperature(const byte scale) {
long rawT = readChannel(CH_TEMPERATURE);
if (scale == DEGREES_C) {
return (int)((rawT * 500 / 1024) - 50);
}
else if (scale == DEGREES_F) {
return (int)((rawT * 450 / 512 ) - 58);
}
else {
return readTemperature(DEGREES_C);
}
}
int _Esplora::readAccelerometer(const byte axis) {
switch (axis) {
case X_AXIS: return analogRead(ACCEL_X_PIN) - ACCEL_ZERO_X;
case Y_AXIS: return analogRead(ACCEL_Y_PIN) - ACCEL_ZERO_Y;
case Z_AXIS: return analogRead(ACCEL_Z_PIN) - ACCEL_ZERO_Z;
default: return 0;
}
}

177
libraries/Esplora/src/Esplora.h
View File

@ -1,177 +0,0 @@
/*
Esplora.h - Arduino Esplora board library
Written by Enrico Gueli
Copyright (c) 2012 Arduino LLC. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef ESPLORA_H_
#define ESPLORA_H_
#include <Arduino.h>
/*
* The following constants are used internally by the Esplora
* library code.
*/
const byte JOYSTICK_BASE = 16; // it's a "virtual" channel: its ID won't conflict with real ones
const byte MAX_CHANNELS = 13;
const byte CH_SWITCH_1 = 0;
const byte CH_SWITCH_2 = 1;
const byte CH_SWITCH_3 = 2;
const byte CH_SWITCH_4 = 3;
const byte CH_SLIDER = 4;
const byte CH_LIGHT = 5;
const byte CH_TEMPERATURE = 6;
const byte CH_MIC = 7;
const byte CH_TINKERKIT_A = 8;
const byte CH_TINKERKIT_B = 9;
const byte CH_JOYSTICK_SW = 10;
const byte CH_JOYSTICK_X = 11;
const byte CH_JOYSTICK_Y = 12;
/*
* The following constants can be used with the readButton()
* method.
*/
const byte SWITCH_1 = 1;
const byte SWITCH_2 = 2;
const byte SWITCH_3 = 3;
const byte SWITCH_4 = 4;
const byte SWITCH_DOWN = SWITCH_1;
const byte SWITCH_LEFT = SWITCH_2;
const byte SWITCH_UP = SWITCH_3;
const byte SWITCH_RIGHT = SWITCH_4;
const byte JOYSTICK_DOWN = JOYSTICK_BASE;
const byte JOYSTICK_LEFT = JOYSTICK_BASE+1;
const byte JOYSTICK_UP = JOYSTICK_BASE+2;
const byte JOYSTICK_RIGHT = JOYSTICK_BASE+3;
/*
* These constants can be use for comparison with the value returned
* by the readButton() method.
*/
const boolean PRESSED = LOW;
const boolean RELEASED = HIGH;
/*
* The following constants can be used with the readTemperature()
* method to specify the desired scale.
*/
const byte DEGREES_C = 0;
const byte DEGREES_F = 1;
/*
* The following constants can be used with the readAccelerometer()
* method to specify the desired axis to return.
*/
const byte X_AXIS = 0;
const byte Y_AXIS = 1;
const byte Z_AXIS = 2;
class _Esplora {
private:
byte lastRed;
byte lastGreen;
byte lastBlue;
unsigned int readChannel(byte channel);
boolean joyLowHalf(byte joyCh);
boolean joyHighHalf(byte joyCh);
public:
_Esplora();
/*
* Returns a number corresponding to the position of the
* linear potentiometer. 0 means full right, 1023 means
* full left.
*/
inline unsigned int readSlider() { return readChannel(CH_SLIDER); }
/*
* Returns a number corresponding to the amount of ambient
* light sensed by the light sensor.
*/
inline unsigned int readLightSensor() { return readChannel(CH_LIGHT); }
/*
* Returns the current ambient temperature, expressed either in Celsius
* or Fahreneit scale.
*/
int readTemperature(const byte scale);
/*
* Returns a number corresponding to the amount of ambient noise.
*/
inline unsigned int readMicrophone() { return readChannel(CH_MIC); }
inline unsigned int readJoystickSwitch() { return readChannel(CH_JOYSTICK_SW); }
inline int readJoystickX() {
return readChannel(CH_JOYSTICK_X) - 512;
}
inline int readJoystickY() {
return readChannel(CH_JOYSTICK_Y) - 512;
}
int readAccelerometer(const byte axis);
/*
* Reads the current state of a button. It will return
* LOW if the button is pressed, and HIGH otherwise.
*/
boolean readButton(byte channel);
boolean readJoystickButton();
void writeRGB(byte red, byte green, byte blue);
void writeRed(byte red);
void writeGreen(byte green);
void writeBlue(byte blue);
byte readRed();
byte readGreen();
byte readBlue();
void tone(unsigned int freq);
void tone(unsigned int freq, unsigned long duration);
void noTone();
inline unsigned int readTinkerkitInput(byte whichInput) {
return readChannel(whichInput + CH_TINKERKIT_A);
}
inline unsigned int readTinkerkitInputA() {
return readChannel(CH_TINKERKIT_A);
}
inline unsigned int readTinkerkitInputB() {
return readChannel(CH_TINKERKIT_B);
}
};
extern _Esplora Esplora;
#endif // ESPLORA_H_