diff options
Diffstat (limited to 'libraries/Esplora/examples')
6 files changed, 581 insertions, 0 deletions
diff --git a/libraries/Esplora/examples/EsploraKart/EsploraKart.ino b/libraries/Esplora/examples/EsploraKart/EsploraKart.ino new file mode 100644 index 0000000..4c1621c --- /dev/null +++ b/libraries/Esplora/examples/EsploraKart/EsploraKart.ino @@ -0,0 +1,125 @@ +/* + 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); +} + diff --git a/libraries/Esplora/examples/EsploraLedShow/EsploraLedShow.ino b/libraries/Esplora/examples/EsploraLedShow/EsploraLedShow.ino new file mode 100644 index 0000000..84f049a --- /dev/null +++ b/libraries/Esplora/examples/EsploraLedShow/EsploraLedShow.ino @@ -0,0 +1,42 @@ +/* + 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 24 Nov 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(xAxis, -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); +} diff --git a/libraries/Esplora/examples/EsploraLedShow2/EsploraLedShow2.ino b/libraries/Esplora/examples/EsploraLedShow2/EsploraLedShow2.ino new file mode 100644 index 0000000..8f9f8a2 --- /dev/null +++ b/libraries/Esplora/examples/EsploraLedShow2/EsploraLedShow2.ino @@ -0,0 +1,55 @@ +/* + 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); +} diff --git a/libraries/Esplora/examples/EsploraMusic/EsploraMusic.ino b/libraries/Esplora/examples/EsploraMusic/EsploraMusic.ino new file mode 100644 index 0000000..10c17f7 --- /dev/null +++ b/libraries/Esplora/examples/EsploraMusic/EsploraMusic.ino @@ -0,0 +1,52 @@ +/* + 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 24 Nov 2012 + by Tom Igoe +*/ + + +#include <Esplora.h> + + +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(); + } +} diff --git a/libraries/Esplora/examples/EsploraRemote/EsploraRemote.ino b/libraries/Esplora/examples/EsploraRemote/EsploraRemote.ino new file mode 100644 index 0000000..135b26a --- /dev/null +++ b/libraries/Esplora/examples/EsploraRemote/EsploraRemote.ino @@ -0,0 +1,94 @@ +/* + 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()); +} diff --git a/libraries/Esplora/examples/EsploraTable/EsploraTable.ino b/libraries/Esplora/examples/EsploraTable/EsploraTable.ino new file mode 100644 index 0000000..712dffa --- /dev/null +++ b/libraries/Esplora/examples/EsploraTable/EsploraTable.ino @@ -0,0 +1,213 @@ +/* + 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; + } +} + |