From 025ec2bc84211a42a3be5e15e44054ba482bf5a0 Mon Sep 17 00:00:00 2001
From: Cristian Maglie <c.maglie@bug.st>
Date: Sun, 16 Dec 2012 14:16:35 +0100
Subject: Fixed malloc() bug. (Paul Stoffregen) Fixes #857

---
 cores/arduino/malloc.c | 380 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 380 insertions(+)
 create mode 100644 cores/arduino/malloc.c

diff --git a/cores/arduino/malloc.c b/cores/arduino/malloc.c
new file mode 100644
index 0000000..9c56600
--- /dev/null
+++ b/cores/arduino/malloc.c
@@ -0,0 +1,380 @@
+/* Copyright (c) 2002, 2004, 2010 Joerg Wunsch
+   Copyright (c) 2010  Gerben van den Broeke
+   All rights reserved.
+
+       malloc, free, realloc from avr-libc 1.7.0
+       with minor modifications, by Paul Stoffregen
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are met:
+
+   * Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+   * Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in
+     the documentation and/or other materials provided with the
+     distribution.
+
+   * Neither the name of the copyright holders nor the names of
+     contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+  POSSIBILITY OF SUCH DAMAGE.
+*/
+ 
+
+#include <stdlib.h>
+#include <inttypes.h>
+#include <string.h>
+#include <avr/io.h>
+
+
+#define __MALLOC_MARGIN__ 120
+
+
+struct __freelist {
+	size_t sz;
+	struct __freelist *nx;
+};
+
+/*
+ * Exported interface:
+ *
+ * When extending the data segment, the allocator will not try to go
+ * beyond the current stack limit, decreased by __malloc_margin bytes.
+ * Thus, all possible stack frames of interrupt routines that could
+ * interrupt the current function, plus all further nested function
+ * calls must not require more stack space, or they'll risk to collide
+ * with the data segment.
+ */
+ 
+
+#define STACK_POINTER() ((char *)AVR_STACK_POINTER_REG)
+extern char __heap_start;
+char *__brkval = &__heap_start;	// first location not yet allocated
+struct __freelist *__flp;	// freelist pointer (head of freelist)
+char *__brkval_maximum = 100;
+
+void *
+malloc(size_t len)
+{
+	struct __freelist *fp1, *fp2, *sfp1, *sfp2;
+	char *cp;
+	size_t s, avail;
+
+	/*
+	 * Our minimum chunk size is the size of a pointer (plus the
+	 * size of the "sz" field, but we don't need to account for
+	 * this), otherwise we could not possibly fit a freelist entry
+	 * into the chunk later.
+	 */
+	if (len < sizeof(struct __freelist) - sizeof(size_t))
+		len = sizeof(struct __freelist) - sizeof(size_t);
+
+	/*
+	 * First, walk the free list and try finding a chunk that
+	 * would match exactly.  If we found one, we are done.  While
+	 * walking, note down the smallest chunk we found that would
+	 * still fit the request -- we need it for step 2.
+	 *
+	 */
+	for (s = 0, fp1 = __flp, fp2 = 0;
+	     fp1;
+	     fp2 = fp1, fp1 = fp1->nx) {
+		if (fp1->sz < len)
+			continue;
+		if (fp1->sz == len) {
+			/*
+			 * Found it.  Disconnect the chunk from the
+			 * freelist, and return it.
+			 */
+			if (fp2)
+				fp2->nx = fp1->nx;
+			else
+				__flp = fp1->nx;
+			return &(fp1->nx);
+		}
+		else {
+			if (s == 0 || fp1->sz < s) {
+				/* this is the smallest chunk found so far */
+				s = fp1->sz;
+				sfp1 = fp1;
+				sfp2 = fp2;
+			}
+		}
+	}
+	/*
+	 * Step 2: If we found a chunk on the freelist that would fit
+	 * (but was too large), look it up again and use it, since it
+	 * is our closest match now.  Since the freelist entry needs
+	 * to be split into two entries then, watch out that the
+	 * difference between the requested size and the size of the
+	 * chunk found is large enough for another freelist entry; if
+	 * not, just enlarge the request size to what we have found,
+	 * and use the entire chunk.
+	 */
+	if (s) {
+		if (s - len < sizeof(struct __freelist)) {
+			/* Disconnect it from freelist and return it. */
+			if (sfp2)
+				sfp2->nx = sfp1->nx;
+			else
+				__flp = sfp1->nx;
+			return &(sfp1->nx);
+		}
+		/*
+		 * Split them up.  Note that we leave the first part
+		 * as the new (smaller) freelist entry, and return the
+		 * upper portion to the caller.  This saves us the
+		 * work to fix up the freelist chain; we just need to
+		 * fixup the size of the current entry, and note down
+		 * the size of the new chunk before returning it to
+		 * the caller.
+		 */
+		cp = (char *)sfp1;
+		s -= len;
+		cp += s;
+		sfp2 = (struct __freelist *)cp;
+		sfp2->sz = len;
+		sfp1->sz = s - sizeof(size_t);
+		return &(sfp2->nx);
+	}
+	/*
+	 * Step 3: If the request could not be satisfied from a
+	 * freelist entry, just prepare a new chunk.  This means we
+	 * need to obtain more memory first.  The largest address just
+	 * not allocated so far is remembered in the brkval variable.
+	 * Under Unix, the "break value" was the end of the data
+	 * segment as dynamically requested from the operating system.
+	 * Since we don't have an operating system, just make sure
+	 * that we don't collide with the stack.
+	 */
+	cp = STACK_POINTER() - __MALLOC_MARGIN__;
+	if (cp <= __brkval)
+	  /*
+	   * Memory exhausted.
+	   */
+	  return 0;
+	avail = cp - __brkval;
+	/*
+	 * Both tests below are needed to catch the case len >= 0xfffe.
+	 */
+	if (avail >= len && avail >= len + sizeof(size_t)) {
+		fp1 = (struct __freelist *)__brkval;
+		__brkval += len + sizeof(size_t);
+		__brkval_maximum = __brkval;
+		fp1->sz = len;
+		return &(fp1->nx);
+	}
+	/*
+	 * Step 4: There's no help, just fail. :-/
+	 */
+	return 0;
+}
+
+
+void
+free(void *p)
+{
+	struct __freelist *fp1, *fp2, *fpnew;
+	char *cp1, *cp2, *cpnew;
+
+	/* ISO C says free(NULL) must be a no-op */
+	if (p == 0)
+		return;
+
+	cpnew = p;
+	cpnew -= sizeof(size_t);
+	fpnew = (struct __freelist *)cpnew;
+	fpnew->nx = 0;
+
+	/*
+	 * Trivial case first: if there's no freelist yet, our entry
+	 * will be the only one on it.  If this is the last entry, we
+	 * can reduce __brkval instead.
+	 */
+	if (__flp == 0) {
+		if ((char *)p + fpnew->sz == __brkval)
+			__brkval = cpnew;
+		else
+			__flp = fpnew;
+		return;
+	}
+
+	/*
+	 * Now, find the position where our new entry belongs onto the
+	 * freelist.  Try to aggregate the chunk with adjacent chunks
+	 * if possible.
+	 */
+	for (fp1 = __flp, fp2 = 0;
+	     fp1;
+	     fp2 = fp1, fp1 = fp1->nx) {
+		if (fp1 < fpnew)
+			continue;
+		cp1 = (char *)fp1;
+		fpnew->nx = fp1;
+		if ((char *)&(fpnew->nx) + fpnew->sz == cp1) {
+			/* upper chunk adjacent, assimilate it */
+			fpnew->sz += fp1->sz + sizeof(size_t);
+			fpnew->nx = fp1->nx;
+		}
+		if (fp2 == 0) {
+			/* new head of freelist */
+			__flp = fpnew;
+			return;
+		}
+		break;
+	}
+	/*
+	 * Note that we get here either if we hit the "break" above,
+	 * or if we fell off the end of the loop.  The latter means
+	 * we've got a new topmost chunk.  Either way, try aggregating
+	 * with the lower chunk if possible.
+	 */
+	fp2->nx = fpnew;
+	cp2 = (char *)&(fp2->nx);
+	if (cp2 + fp2->sz == cpnew) {
+		/* lower junk adjacent, merge */
+		fp2->sz += fpnew->sz + sizeof(size_t);
+		fp2->nx = fpnew->nx;
+	}
+	/*
+	 * If there's a new topmost chunk, lower __brkval instead.
+	 */
+	for (fp1 = __flp, fp2 = 0;
+	     fp1->nx != 0;
+	     fp2 = fp1, fp1 = fp1->nx)
+		/* advance to entry just before end of list */;
+	cp2 = (char *)&(fp1->nx);
+	if (cp2 + fp1->sz == __brkval) {
+		if (fp2 == NULL)
+			/* Freelist is empty now. */
+			__flp = NULL;
+		else
+			fp2->nx = NULL;
+		__brkval = cp2 - sizeof(size_t);
+	}
+}
+
+
+
+void *
+realloc(void *ptr, size_t len)
+{
+	struct __freelist *fp1, *fp2, *fp3, *ofp3;
+	char *cp, *cp1;
+	void *memp;
+	size_t s, incr;
+
+	/* Trivial case, required by C standard. */
+	if (ptr == 0)
+		return malloc(len);
+
+	cp1 = (char *)ptr;
+	cp1 -= sizeof(size_t);
+	fp1 = (struct __freelist *)cp1;
+
+	cp = (char *)ptr + len; /* new next pointer */
+	if (cp < cp1)
+		/* Pointer wrapped across top of RAM, fail. */
+		return 0;
+
+	/*
+	 * See whether we are growing or shrinking.  When shrinking,
+	 * we split off a chunk for the released portion, and call
+	 * free() on it.  Therefore, we can only shrink if the new
+	 * size is at least sizeof(struct __freelist) smaller than the
+	 * previous size.
+	 */
+	if (len <= fp1->sz) {
+		/* The first test catches a possible unsigned int
+		 * rollover condition. */
+		if (fp1->sz <= sizeof(struct __freelist) ||
+		    len > fp1->sz - sizeof(struct __freelist))
+			return ptr;
+		fp2 = (struct __freelist *)cp;
+		fp2->sz = fp1->sz - len - sizeof(size_t);
+		fp1->sz = len;
+		free(&(fp2->nx));
+		return ptr;
+	}
+
+	/*
+	 * If we get here, we are growing.  First, see whether there
+	 * is space in the free list on top of our current chunk.
+	 */
+	incr = len - fp1->sz;
+	cp = (char *)ptr + fp1->sz;
+	fp2 = (struct __freelist *)cp;
+	for (s = 0, ofp3 = 0, fp3 = __flp;
+	     fp3;
+	     ofp3 = fp3, fp3 = fp3->nx) {
+		if (fp3 == fp2 && fp3->sz + sizeof(size_t) >= incr) {
+			/* found something that fits */
+			if (fp3->sz + sizeof(size_t) - incr > sizeof(struct __freelist)) {
+				/* split off a new freelist entry */
+				cp = (char *)ptr + len;
+				fp2 = (struct __freelist *)cp;
+				fp2->nx = fp3->nx;
+				fp2->sz = fp3->sz - incr;
+				fp1->sz = len;
+			} else {
+				/* it just fits, so use it entirely */
+				fp1->sz += fp3->sz + sizeof(size_t);
+				fp2 = fp3->nx;
+			}
+			if (ofp3)
+				ofp3->nx = fp2;
+			else
+				__flp = fp2;
+			return ptr;
+		}
+		/*
+		 * Find the largest chunk on the freelist while
+		 * walking it.
+		 */
+		if (fp3->sz > s)
+			s = fp3->sz;
+	}
+	/*
+	 * If we are the topmost chunk in memory, and there was no
+	 * large enough chunk on the freelist that could be re-used
+	 * (by a call to malloc() below), quickly extend the
+	 * allocation area if possible, without need to copy the old
+	 * data.
+	 */
+	if (__brkval == (char *)ptr + fp1->sz && len > s) {
+		cp = (char *)ptr + len;
+		cp1 = STACK_POINTER() - __MALLOC_MARGIN__;
+		if (cp < cp1) {
+			__brkval = cp;
+			__brkval_maximum = cp;
+			fp1->sz = len;
+			return ptr;
+		}
+		/* If that failed, we are out of luck. */
+		return 0;
+	}
+
+	/*
+	 * Call malloc() for a new chunk, then copy over the data, and
+	 * release the old region.
+	 */
+	if ((memp = malloc(len)) == 0)
+		return 0;
+	memcpy(memp, ptr, fp1->sz);
+	free(ptr);
+	return memp;
+}
+
-- 
cgit v1.2.3-18-g5258


From 09b755fb9c3f5c42fa9b38ffeef0dbfa2cfd8315 Mon Sep 17 00:00:00 2001
From: Cristian Maglie <c.maglie@bug.st>
Date: Sun, 16 Dec 2012 14:30:12 +0100
Subject: Add trivial new[] and delete[] operators (Justin R. Cutler) Fixes #73
 Fixes #883

---
 cores/arduino/new.cpp | 12 +++++++++++-
 cores/arduino/new.h   |  4 +++-
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/cores/arduino/new.cpp b/cores/arduino/new.cpp
index 0f6d422..b81031e 100644
--- a/cores/arduino/new.cpp
+++ b/cores/arduino/new.cpp
@@ -5,10 +5,20 @@ void * operator new(size_t size)
   return malloc(size);
 }
 
+void * operator new[](size_t size)
+{
+  return malloc(size);
+}
+
 void operator delete(void * ptr)
 {
   free(ptr);
-} 
+}
+
+void operator delete[](void * ptr)
+{
+  free(ptr);
+}
 
 int __cxa_guard_acquire(__guard *g) {return !*(char *)(g);};
 void __cxa_guard_release (__guard *g) {*(char *)g = 1;};
diff --git a/cores/arduino/new.h b/cores/arduino/new.h
index cd940ce..991c86c 100644
--- a/cores/arduino/new.h
+++ b/cores/arduino/new.h
@@ -8,7 +8,9 @@
 #include <stdlib.h>
 
 void * operator new(size_t size);
-void operator delete(void * ptr); 
+void * operator new[](size_t size);
+void operator delete(void * ptr);
+void operator delete[](void * ptr);
 
 __extension__ typedef int __guard __attribute__((mode (__DI__)));
 
-- 
cgit v1.2.3-18-g5258


From c01bc2b62f76a5d417e5ed13dcb0c047a4f67224 Mon Sep 17 00:00:00 2001
From: Cristian Maglie <c.maglie@bug.st>
Date: Sun, 6 Jan 2013 18:38:03 +0100
Subject: Merged upcoming 1.0.4 and updated revision log

---
 .../EsploraAccelerometer/EsploraAccelerometer.ino  |  38 ++++
 .../Beginners/EsploraBlink/EsploraBlink.ino        |  42 ++++
 .../EsploraJoystickMouse/EsploraJoystickMouse.ino  |  50 +++++
 .../Beginners/EsploraLedShow/EsploraLedShow.ino    |  42 ++++
 .../Beginners/EsploraLedShow2/EsploraLedShow2.ino  |  55 ++++++
 .../EsploraLightCalibrator.ino                     |  91 +++++++++
 .../Beginners/EsploraMusic/EsploraMusic.ino        |  53 +++++
 .../EsploraSoundSensor/EsploraSoundSensor.ino      |  41 ++++
 .../EsploraTemperatureSensor.ino                   |  37 ++++
 libraries/Esplora/Esplora.cpp                      |   9 +
 libraries/Esplora/Esplora.h                        |   4 +-
 .../Esplora/Experts/EsploraKart/EsploraKart.ino    | 125 ++++++++++++
 .../Esplora/Experts/EsploraPong/EsploraPong.ino    |  44 +++++
 .../Experts/EsploraRemote/EsploraRemote.ino        | 116 +++++++++++
 .../Esplora/Experts/EsploraTable/EsploraTable.ino  | 213 +++++++++++++++++++++
 .../Esplora/examples/EsploraKart/EsploraKart.ino   | 125 ------------
 .../examples/EsploraLedShow/EsploraLedShow.ino     |  42 ----
 .../examples/EsploraLedShow2/EsploraLedShow2.ino   |  55 ------
 .../Esplora/examples/EsploraMusic/EsploraMusic.ino |  52 -----
 .../examples/EsploraRemote/EsploraRemote.ino       |  94 ---------
 .../Esplora/examples/EsploraTable/EsploraTable.ino | 213 ---------------------
 libraries/Esplora/keywords.txt                     |   1 +
 22 files changed, 960 insertions(+), 582 deletions(-)
 create mode 100644 libraries/Esplora/Beginners/EsploraAccelerometer/EsploraAccelerometer.ino
 create mode 100644 libraries/Esplora/Beginners/EsploraBlink/EsploraBlink.ino
 create mode 100644 libraries/Esplora/Beginners/EsploraJoystickMouse/EsploraJoystickMouse.ino
 create mode 100644 libraries/Esplora/Beginners/EsploraLedShow/EsploraLedShow.ino
 create mode 100644 libraries/Esplora/Beginners/EsploraLedShow2/EsploraLedShow2.ino
 create mode 100644 libraries/Esplora/Beginners/EsploraLightCalibrator/EsploraLightCalibrator.ino
 create mode 100644 libraries/Esplora/Beginners/EsploraMusic/EsploraMusic.ino
 create mode 100644 libraries/Esplora/Beginners/EsploraSoundSensor/EsploraSoundSensor.ino
 create mode 100644 libraries/Esplora/Beginners/EsploraTemperatureSensor/EsploraTemperatureSensor.ino
 create mode 100644 libraries/Esplora/Experts/EsploraKart/EsploraKart.ino
 create mode 100644 libraries/Esplora/Experts/EsploraPong/EsploraPong.ino
 create mode 100644 libraries/Esplora/Experts/EsploraRemote/EsploraRemote.ino
 create mode 100644 libraries/Esplora/Experts/EsploraTable/EsploraTable.ino
 delete mode 100644 libraries/Esplora/examples/EsploraKart/EsploraKart.ino
 delete mode 100644 libraries/Esplora/examples/EsploraLedShow/EsploraLedShow.ino
 delete mode 100644 libraries/Esplora/examples/EsploraLedShow2/EsploraLedShow2.ino
 delete mode 100644 libraries/Esplora/examples/EsploraMusic/EsploraMusic.ino
 delete mode 100644 libraries/Esplora/examples/EsploraRemote/EsploraRemote.ino
 delete mode 100644 libraries/Esplora/examples/EsploraTable/EsploraTable.ino

diff --git a/libraries/Esplora/Beginners/EsploraAccelerometer/EsploraAccelerometer.ino b/libraries/Esplora/Beginners/EsploraAccelerometer/EsploraAccelerometer.ino
new file mode 100644
index 0000000..db5cc93
--- /dev/null
+++ b/libraries/Esplora/Beginners/EsploraAccelerometer/EsploraAccelerometer.ino
@@ -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)
+}
+
+
diff --git a/libraries/Esplora/Beginners/EsploraBlink/EsploraBlink.ino b/libraries/Esplora/Beginners/EsploraBlink/EsploraBlink.ino
new file mode 100644
index 0000000..e198551
--- /dev/null
+++ b/libraries/Esplora/Beginners/EsploraBlink/EsploraBlink.ino
@@ -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
+
+}
+
+
diff --git a/libraries/Esplora/Beginners/EsploraJoystickMouse/EsploraJoystickMouse.ino b/libraries/Esplora/Beginners/EsploraJoystickMouse/EsploraJoystickMouse.ino
new file mode 100644
index 0000000..8d9260e
--- /dev/null
+++ b/libraries/Esplora/Beginners/EsploraJoystickMouse/EsploraJoystickMouse.ino
@@ -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
+}
+
diff --git a/libraries/Esplora/Beginners/EsploraLedShow/EsploraLedShow.ino b/libraries/Esplora/Beginners/EsploraLedShow/EsploraLedShow.ino
new file mode 100644
index 0000000..3c617dc
--- /dev/null
+++ b/libraries/Esplora/Beginners/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 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);
+}
diff --git a/libraries/Esplora/Beginners/EsploraLedShow2/EsploraLedShow2.ino b/libraries/Esplora/Beginners/EsploraLedShow2/EsploraLedShow2.ino
new file mode 100644
index 0000000..8f9f8a2
--- /dev/null
+++ b/libraries/Esplora/Beginners/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/Beginners/EsploraLightCalibrator/EsploraLightCalibrator.ino b/libraries/Esplora/Beginners/EsploraLightCalibrator/EsploraLightCalibrator.ino
new file mode 100644
index 0000000..c3eaff4
--- /dev/null
+++ b/libraries/Esplora/Beginners/EsploraLightCalibrator/EsploraLightCalibrator.ino
@@ -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;
+  }
+}
+
+
+
+
+
+
+
+
diff --git a/libraries/Esplora/Beginners/EsploraMusic/EsploraMusic.ino b/libraries/Esplora/Beginners/EsploraMusic/EsploraMusic.ino
new file mode 100644
index 0000000..7a950fb
--- /dev/null
+++ b/libraries/Esplora/Beginners/EsploraMusic/EsploraMusic.ino
@@ -0,0 +1,53 @@
+/*
+  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();
+  }
+}
diff --git a/libraries/Esplora/Beginners/EsploraSoundSensor/EsploraSoundSensor.ino b/libraries/Esplora/Beginners/EsploraSoundSensor/EsploraSoundSensor.ino
new file mode 100644
index 0000000..3bf454f
--- /dev/null
+++ b/libraries/Esplora/Beginners/EsploraSoundSensor/EsploraSoundSensor.ino
@@ -0,0 +1,41 @@
+/*
+  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); 
+}
+
diff --git a/libraries/Esplora/Beginners/EsploraTemperatureSensor/EsploraTemperatureSensor.ino b/libraries/Esplora/Beginners/EsploraTemperatureSensor/EsploraTemperatureSensor.ino
new file mode 100644
index 0000000..72bbf04
--- /dev/null
+++ b/libraries/Esplora/Beginners/EsploraTemperatureSensor/EsploraTemperatureSensor.ino
@@ -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);
+}
+
+
diff --git a/libraries/Esplora/Esplora.cpp b/libraries/Esplora/Esplora.cpp
index 83df0d7..29c9e19 100644
--- a/libraries/Esplora/Esplora.cpp
+++ b/libraries/Esplora/Esplora.cpp
@@ -111,6 +111,15 @@ boolean _Esplora::readButton(byte 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);
diff --git a/libraries/Esplora/Esplora.h b/libraries/Esplora/Esplora.h
index 74fa88b..4f55345 100644
--- a/libraries/Esplora/Esplora.h
+++ b/libraries/Esplora/Esplora.h
@@ -21,7 +21,7 @@
 #ifndef ESPLORA_H_
 #define ESPLORA_H_
 
-#include "Arduino.h"
+#include <Arduino.h>
 
 /*
  * The following constants are used internally by the Esplora
@@ -141,6 +141,8 @@ public:
    * 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);
diff --git a/libraries/Esplora/Experts/EsploraKart/EsploraKart.ino b/libraries/Esplora/Experts/EsploraKart/EsploraKart.ino
new file mode 100644
index 0000000..4c1621c
--- /dev/null
+++ b/libraries/Esplora/Experts/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/Experts/EsploraPong/EsploraPong.ino b/libraries/Esplora/Experts/EsploraPong/EsploraPong.ino
new file mode 100644
index 0000000..725a109
--- /dev/null
+++ b/libraries/Esplora/Experts/EsploraPong/EsploraPong.ino
@@ -0,0 +1,44 @@
+/*
+  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
+}
+
diff --git a/libraries/Esplora/Experts/EsploraRemote/EsploraRemote.ino b/libraries/Esplora/Experts/EsploraRemote/EsploraRemote.ino
new file mode 100644
index 0000000..2701089
--- /dev/null
+++ b/libraries/Esplora/Experts/EsploraRemote/EsploraRemote.ino
@@ -0,0 +1,116 @@
+/*
+  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() {
+  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() {  
+  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/Experts/EsploraTable/EsploraTable.ino b/libraries/Esplora/Experts/EsploraTable/EsploraTable.ino
new file mode 100644
index 0000000..712dffa
--- /dev/null
+++ b/libraries/Esplora/Experts/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;
+  }
+}
+
diff --git a/libraries/Esplora/examples/EsploraKart/EsploraKart.ino b/libraries/Esplora/examples/EsploraKart/EsploraKart.ino
deleted file mode 100644
index 4c1621c..0000000
--- a/libraries/Esplora/examples/EsploraKart/EsploraKart.ino
+++ /dev/null
@@ -1,125 +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);
-}
-
diff --git a/libraries/Esplora/examples/EsploraLedShow/EsploraLedShow.ino b/libraries/Esplora/examples/EsploraLedShow/EsploraLedShow.ino
deleted file mode 100644
index 84f049a..0000000
--- a/libraries/Esplora/examples/EsploraLedShow/EsploraLedShow.ino
+++ /dev/null
@@ -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 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
deleted file mode 100644
index 8f9f8a2..0000000
--- a/libraries/Esplora/examples/EsploraLedShow2/EsploraLedShow2.ino
+++ /dev/null
@@ -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); 
-}
diff --git a/libraries/Esplora/examples/EsploraMusic/EsploraMusic.ino b/libraries/Esplora/examples/EsploraMusic/EsploraMusic.ino
deleted file mode 100644
index 10c17f7..0000000
--- a/libraries/Esplora/examples/EsploraMusic/EsploraMusic.ino
+++ /dev/null
@@ -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 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
deleted file mode 100644
index 135b26a..0000000
--- a/libraries/Esplora/examples/EsploraRemote/EsploraRemote.ino
+++ /dev/null
@@ -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());
-}
diff --git a/libraries/Esplora/examples/EsploraTable/EsploraTable.ino b/libraries/Esplora/examples/EsploraTable/EsploraTable.ino
deleted file mode 100644
index 712dffa..0000000
--- a/libraries/Esplora/examples/EsploraTable/EsploraTable.ino
+++ /dev/null
@@ -1,213 +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;
-  }
-}
-
diff --git a/libraries/Esplora/keywords.txt b/libraries/Esplora/keywords.txt
index 02ba660..b225991 100644
--- a/libraries/Esplora/keywords.txt
+++ b/libraries/Esplora/keywords.txt
@@ -16,6 +16,7 @@ readLightSensor	KEYWORD2
 readTemperature	KEYWORD2
 readMicrophone	KEYWORD2
 readJoystickSwitch	KEYWORD2
+readJoystickButton	KEYWORD2
 readJoystickX	KEYWORD2
 readJoystickY	KEYWORD2
 readAccelerometer	KEYWORD2
-- 
cgit v1.2.3-18-g5258


From 37604e695dd8b4fa5c3884f2e24a2b7c8ca30958 Mon Sep 17 00:00:00 2001
From: Federico Fissore <f.fissore@arduino.cc>
Date: Thu, 10 Jan 2013 14:53:20 +0100
Subject: wrong comment in Firmata.cpp. closes #786 #785

---
 libraries/Firmata/Firmata.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libraries/Firmata/Firmata.cpp b/libraries/Firmata/Firmata.cpp
index e81c10b..36f8ed1 100644
--- a/libraries/Firmata/Firmata.cpp
+++ b/libraries/Firmata/Firmata.cpp
@@ -245,7 +245,7 @@ void FirmataClass::processInput(void)
       break;
     case REPORT_ANALOG:
     case REPORT_DIGITAL:
-      waitForData = 1; // two data bytes needed
+      waitForData = 1; // one data byte needed
       executeMultiByteCommand = command;
       break;
     case START_SYSEX:
-- 
cgit v1.2.3-18-g5258


From c6287dd6ac33544179a6544b8f3f55a396ec6608 Mon Sep 17 00:00:00 2001
From: Federico Fissore <f.fissore@arduino.cc>
Date: Thu, 10 Jan 2013 16:30:07 +0100
Subject: closes #954: wrong header name in WebServer example sketches

---
 libraries/Ethernet/examples/WebServer/WebServer.ino     | 2 +-
 libraries/WiFi/examples/WifiWebServer/WifiWebServer.ino | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/libraries/Ethernet/examples/WebServer/WebServer.ino b/libraries/Ethernet/examples/WebServer/WebServer.ino
index ce8dbb1..0573f05 100644
--- a/libraries/Ethernet/examples/WebServer/WebServer.ino
+++ b/libraries/Ethernet/examples/WebServer/WebServer.ino
@@ -63,7 +63,7 @@ void loop() {
           // send a standard http response header
           client.println("HTTP/1.1 200 OK");
           client.println("Content-Type: text/html");
-          client.println("Connnection: close");
+          client.println("Connection: close");
           client.println();
           client.println("<!DOCTYPE HTML>");
           client.println("<html>");
diff --git a/libraries/WiFi/examples/WifiWebServer/WifiWebServer.ino b/libraries/WiFi/examples/WifiWebServer/WifiWebServer.ino
index ac5f056..a514e15 100644
--- a/libraries/WiFi/examples/WifiWebServer/WifiWebServer.ino
+++ b/libraries/WiFi/examples/WifiWebServer/WifiWebServer.ino
@@ -76,7 +76,7 @@ void loop() {
           // send a standard http response header
           client.println("HTTP/1.1 200 OK");
           client.println("Content-Type: text/html");
-          client.println("Connnection: close");
+          client.println("Connection: close");
           client.println();
           client.println("<!DOCTYPE HTML>");
           client.println("<html>");
-- 
cgit v1.2.3-18-g5258