an mbed tile music game using a capacitive touchpad and uLCD

Dependencies:   SDFileSystem mbed wave_player

Files at this revision

API Documentation at this revision

Comitter:
clu67
Date:
Mon Mar 14 00:26:24 2016 +0000
Commit message:
Initial Release

Changed in this revision

4DGL-uLCD-SE/uLCD_4DGL.h Show annotated file Show diff for this revision Revisions of this file
4DGL-uLCD-SE/uLCD_4DGL_Graphics.cpp Show annotated file Show diff for this revision Revisions of this file
4DGL-uLCD-SE/uLCD_4DGL_Media.cpp Show annotated file Show diff for this revision Revisions of this file
4DGL-uLCD-SE/uLCD_4DGL_Text.cpp Show annotated file Show diff for this revision Revisions of this file
4DGL-uLCD-SE/uLCD_4DGL_main.cpp Show annotated file Show diff for this revision Revisions of this file
SDFileSystem.lib Show annotated file Show diff for this revision Revisions of this file
SongPlayer.h Show annotated file Show diff for this revision Revisions of this file
main.cpp Show annotated file Show diff for this revision Revisions of this file
mbed.bld Show annotated file Show diff for this revision Revisions of this file
mpr121/mpr121.cpp Show annotated file Show diff for this revision Revisions of this file
mpr121/mpr121.h Show annotated file Show diff for this revision Revisions of this file
wave_player.lib Show annotated file Show diff for this revision Revisions of this file
diff -r 000000000000 -r a1c374b9a4fe 4DGL-uLCD-SE/uLCD_4DGL.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/4DGL-uLCD-SE/uLCD_4DGL.h	Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,348 @@
+//
+// uLCD_4DGL is a class to drive 4D Systems TFT touch screens
+//
+// Fork of 4DGL library for 4D Systems LCD displays
+// Copyright (C) <2010> Stephane ROCHON <stephane.rochon at free.fr>
+// Modifed for Goldelox processor <2013> Jim Hamblen
+//
+// uLCD_4DGL is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// uLCD_4DGL 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with uLCD_4DGL.  If not, see <http://www.gnu.org/licenses/>.
+
+// @author Stephane Rochon
+
+#include "mbed.h"
+#ifndef _uLCD
+#define _uLCD 0
+// Debug Verbose off - SGE commands echoed to USB serial for debugmode=1
+#ifndef DEBUGMODE
+#define DEBUGMODE 0
+#endif
+
+// Common WAIT value in milliseconds between commands
+#define TEMPO 0
+
+// 4DGL SGE Function values for Goldelox Processor
+#define CLS          '\xD7'
+#define BAUDRATE     '\x0B' //null prefix
+#define VERSION      '\x08' //null prefix
+#define BCKGDCOLOR   '\x6E'
+#define TXTBCKGDCOLOR '\x7E'
+#define DISPCONTROL  '\x68'
+#define SETVOLUME    '\x76'
+#define CIRCLE       '\xCD'
+#define FCIRCLE      '\xCC'
+#define TRIANGLE     '\xC9'
+#define LINE         '\xD2'
+#define FRECTANGLE   '\xCE'
+#define RECTANGLE    '\xCF'
+#define ELLIPSE      '\x65' //na
+#define PIXEL        '\xCB'
+#define READPIXEL    '\xCA'
+#define SCREENCOPY   '\x63'  //na?
+#define PENSIZE      '\xD8'
+#define SETFONT      '\x7D'
+#define TEXTMODE     '\x77'
+#define TEXTBOLD     '\x76'
+#define TEXTITALIC   '\x75'
+#define TEXTINVERSE  '\x74'
+#define TEXTUNDERLINE '\x73'
+#define TEXTWIDTH    '\x7C'
+#define TEXTHEIGHT   '\x7B'
+#define TEXTCHAR     '\xFE'
+#define TEXTSTRING   '\x06'  //null prefix
+#define MOVECURSOR   '\xE4'
+#define BLITCOM      '\x0A'
+#define PUTCHAR      '\xFE'
+#define DISPPOWER    '\x66'
+//media commands for uSD card
+#define MINIT        '\xB1'
+#define SBADDRESS    '\xB9'
+#define SSADDRESS    '\xB8'
+#define READBYTE     '\xB7'
+#define READWORD     '\xB6'
+#define WRITEBYTE    '\xB5'
+#define WRITEWORD    '\xB4'
+#define FLUSHMEDIA   '\xB2'
+#define DISPLAYIMAGE '\xB3'
+#define DISPLAYVIDEO '\xBB'
+#define DISPLAYFRAME '\xBA'
+
+
+
+// Screen answers
+#define ACK          '\x06'
+#define NAK          '\x15'
+
+
+
+// Screen states
+#define OFF          '\x00'
+#define ON           '\x01'
+
+// Graphics modes
+#define SOLID        '\x00'
+#define WIREFRAME    '\x01'
+
+// Text modes
+#define TRANSPARENT  '\x00'
+#define OPAQUE       '\x01'
+
+// Fonts Sizes
+#define FONT_7X8     '\x00' //only builtin font 
+#define FONT_5X7     '\x04'
+#define FONT_8X8     '\x01'
+#define FONT_8X12    '\x02'
+#define FONT_12X16   '\x03'
+#define MEDIAFONT    '\x07'
+
+
+// Data speed
+#define BAUD_110     27271
+#define BAUD_300     9999
+#define BAUD_600     4999
+#define BAUD_1200    2499
+#define BAUD_2400    1249
+#define BAUD_4800    624
+#define BAUD_9600    312
+#define BAUD_14400   207
+#define BAUD_19200   155
+#define BAUD_31250   95
+#define BAUD_38400   77
+#define BAUD_56000   53
+#define BAUD_57600   51
+#define BAUD_115200  25
+#define BAUD_128000  22
+#define BAUD_256000  11
+#define BAUD_300000  10
+#define BAUD_375000  8
+#define BAUD_500000  6
+#define BAUD_600000  4
+#define BAUD_750000  3
+#define BAUD_1000000 2
+#define BAUD_1500000 1
+#define BAUD_3000000 0
+
+// Defined Colors
+#define WHITE 0xFFFFFF
+#define BLACK 0x000000
+#define RED   0xFF0000
+#define GREEN 0x00FF00
+#define BLUE  0x0000FF
+#define LGREY 0xBFBFBF
+#define DGREY 0x5F5F5F
+
+// Mode data
+#define BACKLIGHT    '\x00'
+#define DISPLAY      '\x01'
+#define CONTRAST     '\x02'
+#define POWER        '\x03'
+#define ORIENTATION  '\x04'
+#define TOUCH_CTRL   '\x05'
+#define IMAGE_FORMAT '\x06'
+#define PROTECT_FAT  '\x08'
+
+// change this to your specific screen (newer versions) if needed
+// Startup orientation is PORTRAIT so SIZE_X must be lesser than SIZE_Y
+//uLCD144-G2 is a 128 by 128 pixel display
+#define SIZE_X       128
+#define SIZE_Y       128
+
+#define IS_LANDSCAPE 0
+#define IS_PORTRAIT  1
+
+// Screen orientation
+#define LANDSCAPE    '\x00'
+#define LANDSCAPE_R  '\x01'
+#define PORTRAIT     '\x02'
+#define PORTRAIT_R   '\x03'
+
+// Parameters
+#define ENABLE       '\x00'
+#define DISABLE      '\x01'
+#define RESET        '\x02'
+
+#define NEW          '\x00'
+#define OLD          '\x01'
+
+#define DOWN         '\x00'
+#define UP           '\x01'
+
+#define PROTECT      '\x00'
+#define UNPROTECT    '\x02'
+
+//**************************************************************************
+// \class uLCD_4DGL uLCD_4DGL.h
+// \brief This is the main class. It shoud be used like this : uLCD_4GDL myLCD(p9,p10,p11);
+/**
+Example:
+* @code
+* // Display a white circle on the screen
+* #include "mbed.h"
+* #include " uLCD_4DGL.h"
+*
+* uLCD_4GDL myLCD(p9,p10,p11);
+*
+* int main() {
+*     myLCD.circle(120, 160, 80, WHITE);
+* }
+* @endcode
+*/
+
+class uLCD_4DGL : public Stream
+{
+
+public :
+
+    uLCD_4DGL(PinName tx, PinName rx, PinName rst);
+
+// General Commands *******************************************************************************
+
+    /** Clear the entire screen using the current background colour */
+    void cls();
+
+    /** Reset screen */
+    void reset();
+
+
+    /** Set serial Baud rate (both sides : screen and mbed)
+    * @param Speed Correct BAUD value (see uLCD_4DGL.h)
+    */
+    void baudrate(int speed);
+
+    /** Set background colour to the specified value
+    * @param color in HEX RGB like 0xFF00FF
+    */
+    void background_color(int color);
+
+    /** Set screen display mode to specific values
+    * @param mode See 4DGL documentation
+    * @param value See 4DGL documentation
+    */
+    void textbackground_color(int color);
+
+    /** Set screen display mode to specific values
+    * @param mode See 4DGL documentation
+    * @param value See 4DGL documentation
+    */
+    void display_control(char mode);
+    void display_power(char mode);
+    /** Set internal speaker to specified value
+    * @param value Correct range is 8 - 127
+    */
+    void set_volume(char value);
+
+// Graphics Commands *******************************************************************************
+
+    /** Draw a circle centered at x,y with a radius and a colour. It uses Pen Size stored value to draw a solid or wireframe circle
+    * @param x Horizontal position of the circle centre
+    * @param y Vertical position of the circle centre
+    * @param radius Radius of the circle
+    * @param color Circle color in HEX RGB like 0xFF00FF
+    */
+    void circle(int x , int y , int radius, int color);
+    void filled_circle(int x , int y , int radius, int color);
+    void triangle(int, int, int, int, int, int, int);
+    void line(int, int, int, int, int);
+    void rectangle(int, int, int, int, int);
+    void filled_rectangle(int, int, int, int, int);
+    void pixel(int, int, int);
+    int  read_pixel(int, int);
+    void pen_size(char);
+    void BLIT(int x, int y, int w, int h, int *colors);
+
+// Text Commands
+    void set_font(char);
+    void set_font_size(char width, char height);  
+    void text_mode(char);
+    void text_bold(char);
+    void text_italic(char);
+    void text_inverse(char);
+    void text_underline(char);
+    void text_width(char);
+    void text_height(char);
+    void text_char(char, char, char, int);
+    void text_string(char *, char, char, char, int);
+    void locate(char, char);
+    void color(int);
+    void putc(char);
+    void puts(char *);
+
+//Media Commands
+    int media_init();
+    void set_byte_address(int, int);
+    void set_sector_address(int, int);
+    char read_byte();
+    int  read_word();
+    void write_byte(int);
+    void write_word(int);
+    void flush_media();
+    void display_image(int, int);
+    void display_video(int, int);
+    void display_frame(int, int, int);
+
+// Screen Data
+    int type;
+    int revision;
+    int firmware;
+    int reserved1;
+    int reserved2;
+
+// Text data
+    char current_col;
+    char current_row;
+    int  current_color;
+    char current_font;
+    char current_orientation;
+    char max_col;
+    char max_row;
+    int current_w, current_h;
+    int current_fx, current_fy;
+    int current_wf, current_hf;
+
+
+protected :
+
+    Serial     _cmd;
+    DigitalOut _rst;
+    //used by printf
+    virtual int _putc(int c) {
+        putc(c);
+        return 0;
+    };
+    virtual int _getc() {
+        return -1;
+    }
+
+    void freeBUFFER  (void);
+    void writeBYTE   (char);
+    void writeBYTEfast   (char);
+    int  writeCOMMAND(char *, int);
+    int  writeCOMMANDnull(char *, int);
+    int  readVERSION (char *, int);
+    int  getSTATUS   (char *, int);
+    int  version     (void);
+#if DEBUGMODE
+    Serial pc;
+#endif // DEBUGMODE
+};
+
+typedef unsigned char BYTE;
+#endif
+
+
+
+
+
+
+
+
diff -r 000000000000 -r a1c374b9a4fe 4DGL-uLCD-SE/uLCD_4DGL_Graphics.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/4DGL-uLCD-SE/uLCD_4DGL_Graphics.cpp	Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,311 @@
+//
+// uLCD_4DGL is a class to drive 4D Systems LCD screens
+//
+// Copyright (C) <2010> Stephane ROCHON <stephane.rochon at free.fr>
+// Modifed for Goldelox processor <2013> Jim Hamblen
+//
+// uLCD_4DGL is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// uLCD_4DGL 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with uLCD_4DGL.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "mbed.h"
+#include "uLCD_4DGL.h"
+
+#define ARRAY_SIZE(X) sizeof(X)/sizeof(X[0])
+
+//****************************************************************************************************
+void uLCD_4DGL :: circle(int x, int y , int radius, int color)     // draw a circle in (x,y)
+{
+    char command[9]= "";
+
+    command[0] = CIRCLE;
+
+    command[1] = (x >> 8) & 0xFF;
+    command[2] = x & 0xFF;
+
+    command[3] = (y >> 8) & 0xFF;
+    command[4] = y & 0xFF;
+
+    command[5] = (radius >> 8) & 0xFF;
+    command[6] = radius & 0xFF;
+
+    int red5   = (color >> (16 + 3)) & 0x1F;              // get red on 5 bits
+    int green6 = (color >> (8 + 2))  & 0x3F;              // get green on 6 bits
+    int blue5  = (color >> (0 + 3))  & 0x1F;              // get blue on 5 bits
+
+    command[7] = ((red5 << 3)   + (green6 >> 3)) & 0xFF;  // first part of 16 bits color
+    command[8] = ((green6 << 5) + (blue5 >>  0)) & 0xFF;  // second part of 16 bits color
+
+    writeCOMMAND(command, 9);
+}
+//****************************************************************************************************
+void uLCD_4DGL :: filled_circle(int x, int y , int radius, int color)     // draw a circle in (x,y)
+{
+    char command[9]= "";
+
+    command[0] = FCIRCLE;
+
+    command[1] = (x >> 8) & 0xFF;
+    command[2] = x & 0xFF;
+
+    command[3] = (y >> 8) & 0xFF;
+    command[4] = y & 0xFF;
+
+    command[5] = (radius >> 8) & 0xFF;
+    command[6] = radius & 0xFF;
+
+    int red5   = (color >> (16 + 3)) & 0x1F;              // get red on 5 bits
+    int green6 = (color >> (8 + 2))  & 0x3F;              // get green on 6 bits
+    int blue5  = (color >> (0 + 3))  & 0x1F;              // get blue on 5 bits
+
+    command[7] = ((red5 << 3)   + (green6 >> 3)) & 0xFF;  // first part of 16 bits color
+    command[8] = ((green6 << 5) + (blue5 >>  0)) & 0xFF;  // second part of 16 bits color
+
+    writeCOMMAND(command, 9);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: triangle(int x1, int y1 , int x2, int y2, int x3, int y3, int color)     // draw a traingle
+{
+    char command[15]= "";
+
+    command[0] = TRIANGLE;
+
+    command[1] = (x1 >> 8) & 0xFF;
+    command[2] = x1 & 0xFF;
+
+    command[3] = (y1 >> 8) & 0xFF;
+    command[4] = y1 & 0xFF;
+
+    command[5] = (x2 >> 8) & 0xFF;
+    command[6] = x2 & 0xFF;
+
+    command[7] = (y2 >> 8) & 0xFF;
+    command[8] = y2 & 0xFF;
+
+    command[9] = (x3 >> 8) & 0xFF;
+    command[10] = x3 & 0xFF;
+
+    command[11] = (y3 >> 8) & 0xFF;
+    command[12] = y3 & 0xFF;
+
+    int red5   = (color >> (16 + 3)) & 0x1F;               // get red on 5 bits
+    int green6 = (color >> (8 + 2))  & 0x3F;               // get green on 6 bits
+    int blue5  = (color >> (0 + 3))  & 0x1F;               // get blue on 5 bits
+
+    command[13] = ((red5 << 3)   + (green6 >> 3)) & 0xFF;  // first part of 16 bits color
+    command[14] = ((green6 << 5) + (blue5 >>  0)) & 0xFF;  // second part of 16 bits color
+
+    writeCOMMAND(command, 15);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: line(int x1, int y1 , int x2, int y2, int color)     // draw a line
+{
+    char command[11]= "";
+
+    command[0] = LINE;
+
+    command[1] = (x1 >> 8) & 0xFF;
+    command[2] = x1 & 0xFF;
+
+    command[3] = (y1 >> 8) & 0xFF;
+    command[4] = y1 & 0xFF;
+
+    command[5] = (x2 >> 8) & 0xFF;
+    command[6] = x2 & 0xFF;
+
+    command[7] = (y2 >> 8) & 0xFF;
+    command[8] = y2 & 0xFF;
+
+    int red5   = (color >> (16 + 3)) & 0x1F;               // get red on 5 bits
+    int green6 = (color >> (8 + 2))  & 0x3F;               // get green on 6 bits
+    int blue5  = (color >> (0 + 3))  & 0x1F;               // get blue on 5 bits
+
+    command[9] = ((red5 << 3)   + (green6 >> 3)) & 0xFF;   // first part of 16 bits color
+    command[10] = ((green6 << 5) + (blue5 >>  0)) & 0xFF;  // second part of 16 bits color
+
+    writeCOMMAND(command, 11);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: rectangle(int x1, int y1 , int x2, int y2, int color)     // draw a rectangle
+{
+    char command[11]= "";
+
+    command[0] = RECTANGLE;
+
+    command[1] = (x1 >> 8) & 0xFF;
+    command[2] = x1 & 0xFF;
+
+    command[3] = (y1 >> 8) & 0xFF;
+    command[4] = y1 & 0xFF;
+
+    command[5] = (x2 >> 8) & 0xFF;
+    command[6] = x2 & 0xFF;
+
+    command[7] = (y2 >> 8) & 0xFF;
+    command[8] = y2 & 0xFF;
+
+    int red5   = (color >> (16 + 3)) & 0x1F;               // get red on 5 bits
+    int green6 = (color >> (8 + 2))  & 0x3F;               // get green on 6 bits
+    int blue5  = (color >> (0 + 3))  & 0x1F;               // get blue on 5 bits
+
+    command[9] = ((red5 << 3)   + (green6 >> 3)) & 0xFF;   // first part of 16 bits color
+    command[10] = ((green6 << 5) + (blue5 >>  0)) & 0xFF;  // second part of 16 bits color
+
+    writeCOMMAND(command, 11);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: filled_rectangle(int x1, int y1 , int x2, int y2, int color)     // draw a rectangle
+{
+    char command[11]= "";
+
+    command[0] = FRECTANGLE;
+
+    command[1] = (x1 >> 8) & 0xFF;
+    command[2] = x1 & 0xFF;
+
+    command[3] = (y1 >> 8) & 0xFF;
+    command[4] = y1 & 0xFF;
+
+    command[5] = (x2 >> 8) & 0xFF;
+    command[6] = x2 & 0xFF;
+
+    command[7] = (y2 >> 8) & 0xFF;
+    command[8] = y2 & 0xFF;
+
+    int red5   = (color >> (16 + 3)) & 0x1F;               // get red on 5 bits
+    int green6 = (color >> (8 + 2))  & 0x3F;               // get green on 6 bits
+    int blue5  = (color >> (0 + 3))  & 0x1F;               // get blue on 5 bits
+
+    command[9] = ((red5 << 3)   + (green6 >> 3)) & 0xFF;   // first part of 16 bits color
+    command[10] = ((green6 << 5) + (blue5 >>  0)) & 0xFF;  // second part of 16 bits color
+
+    writeCOMMAND(command, 11);
+}
+
+
+
+//****************************************************************************************************
+void uLCD_4DGL :: pixel(int x, int y, int color)     // draw a pixel
+{
+    char command[7]= "";
+
+    command[0] = PIXEL;
+
+    command[1] = (x >> 8) & 0xFF;
+    command[2] = x & 0xFF;
+
+    command[3] = (y >> 8) & 0xFF;
+    command[4] = y & 0xFF;
+
+    int red5   = (color >> (16 + 3)) & 0x1F;              // get red on 5 bits
+    int green6 = (color >> (8 + 2))  & 0x3F;              // get green on 6 bits
+    int blue5  = (color >> (0 + 3))  & 0x1F;              // get blue on 5 bits
+
+    command[5] = ((red5 << 3)   + (green6 >> 3)) & 0xFF;  // first part of 16 bits color
+    command[6] = ((green6 << 5) + (blue5 >>  0)) & 0xFF;  // second part of 16 bits color
+
+    writeCOMMAND(command, 7);
+}
+//****************************************************************************************************
+void uLCD_4DGL :: BLIT(int x, int y, int w, int h, int *colors)     // draw a block of pixels
+{
+    int red5, green6, blue5;
+    writeBYTEfast('\x00');
+    writeBYTEfast(BLITCOM);
+    writeBYTEfast((x >> 8) & 0xFF);
+    writeBYTEfast(x & 0xFF);
+    writeBYTEfast((y >> 8) & 0xFF);
+    writeBYTEfast(y & 0xFF);
+    writeBYTEfast((w >> 8) & 0xFF);
+    writeBYTE(w & 0xFF);
+    writeBYTE((h >> 8) & 0xFF);
+    writeBYTE(h & 0xFF);
+    wait_ms(1);
+    for (int i=0; i<w*h; i++) {
+        red5   = (colors[i] >> (16 + 3)) & 0x1F;              // get red on 5 bits
+        green6 = (colors[i] >> (8 + 2))  & 0x3F;              // get green on 6 bits
+        blue5  = (colors[i] >> (0 + 3))  & 0x1F;              // get blue on 5 bits
+        writeBYTEfast(((red5 << 3)   + (green6 >> 3)) & 0xFF);  // first part of 16 bits color
+        writeBYTEfast(((green6 << 5) + (blue5 >> 0)) & 0xFF);  // second part of 16 bits color
+    }
+    int resp=0;
+    while (!_cmd.readable()) wait_ms(TEMPO);              // wait for screen answer
+    if (_cmd.readable()) resp = _cmd.getc();           // read response if any
+    switch (resp) {
+        case ACK :                                     // if OK return   1
+            resp =  1;
+            break;
+        case NAK :                                     // if NOK return -1
+            resp = -1;
+            break;
+        default :
+            resp =  0;                                 // else return   0
+            break;
+    }
+#if DEBUGMODE
+    pc.printf("   Answer received : %d\n",resp);
+#endif
+
+}
+//******************************************************************************************************
+int uLCD_4DGL :: read_pixel(int x, int y)   // read screen info and populate data
+{
+
+    char command[6]= "";
+    command[0] = 0xFF;
+    command[1] = READPIXEL;
+
+    command[2] = (x >> 8) & 0xFF;
+    command[3] = x & 0xFF;
+
+    command[4] = (y >> 8) & 0xFF;
+    command[5] = y & 0xFF;
+
+    int i, temp = 0, color = 0, resp = 0;
+    char response[3] = "";
+
+    freeBUFFER();
+
+    for (i = 0; i < 6; i++) {                   // send all chars to serial port
+        writeBYTE(command[i]);
+    }
+
+    while (!_cmd.readable()) wait_ms(TEMPO);    // wait a bit for screen answer
+
+    while ( resp < ARRAY_SIZE(response)) {   //read ack and 16-bit color response
+        temp = _cmd.getc();
+        response[resp++] = (char)temp;
+    }
+
+    color = ((response[1] << 8) + response[2]);
+
+    return color; 
+}
+
+
+//****************************************************************************************************
+void uLCD_4DGL :: pen_size(char mode)     // set pen to SOLID or WIREFRAME
+{
+    char command[2]= "";
+
+    command[0] = PENSIZE;
+    command[1] = mode;
+    writeCOMMAND(command, 2);
+}
+
+
+
+
diff -r 000000000000 -r a1c374b9a4fe 4DGL-uLCD-SE/uLCD_4DGL_Media.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/4DGL-uLCD-SE/uLCD_4DGL_Media.cpp	Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,178 @@
+//
+// uLCD_4DGL is a class to drive 4D Systems LCD screens
+//
+// Copyright (C) <2010> Stephane ROCHON <stephane.rochon at free.fr>
+// Modifed for Goldelox processor <2013> Jim Hamblen
+//
+// uLCD_4DGL is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// uLCD_4DGL 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with uLCD_4DGL.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "mbed.h"
+#include "uLCD_4DGL.h"
+
+
+//Media Commands
+
+//******************************************************************************************************
+int uLCD_4DGL :: media_init()
+{
+    int resp = 0;
+    char command[1] = "";
+    command[0] = MINIT;
+    writeCOMMAND(command, 1);
+    while (!_cmd.readable()) wait_ms(TEMPO);              // wait for screen answer
+    if (_cmd.readable()) {
+        resp = _cmd.getc();           // read response
+        resp = resp << 8 + _cmd.getc();
+    }
+    return resp;
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: set_byte_address(int hi, int lo)
+{
+    char command[5]= "";
+    command[0] = SBADDRESS;
+
+    command[1] = (hi >> 8) & 0xFF;
+    command[2] = hi & 0xFF;
+
+    command[3] = (lo >> 8) & 0xFF;
+    command[4] = lo & 0xFF;
+    writeCOMMAND(command, 5);
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: set_sector_address(int hi, int lo)
+{
+
+    char command[5]= "";
+    command[0] = SSADDRESS;
+
+    command[1] = (hi >> 8) & 0xFF;
+    command[2] = hi & 0xFF;
+
+    command[3] = (lo >> 8) & 0xFF;
+    command[4] = lo & 0xFF;
+    writeCOMMAND(command, 5);
+}
+
+//******************************************************************************************************
+char uLCD_4DGL :: read_byte()
+{
+    char resp = 0;
+    char command[1] = "";
+    command[0] = READBYTE;
+    writeCOMMAND(command, 1);
+    while (!_cmd.readable()) wait_ms(TEMPO);              // wait for screen answer
+    if (_cmd.readable()) {
+        resp = _cmd.getc();           // read response
+        resp = _cmd.getc();
+    }
+    return resp;
+}
+
+//******************************************************************************************************
+int  uLCD_4DGL :: read_word()
+{
+    int resp=0;
+    char command[1] = "";
+    command[0] = READWORD;
+    writeCOMMAND(command, 1);
+    while (!_cmd.readable()) wait_ms(TEMPO);              // wait for screen answer
+    if (_cmd.readable()) {
+        resp = _cmd.getc();           // read response
+        resp = resp << 8 + _cmd.getc();
+    }
+    return resp;
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: write_byte(int value)
+{
+    char command[3]= "";
+
+    command[0] = WRITEBYTE;
+
+    command[1] = (value >> 8) & 0xFF;
+    command[2] = value & 0xFF;
+    writeCOMMAND(command,3);
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: write_word(int value)
+{
+    char command[3]= "";
+
+    command[0] = WRITEWORD;
+
+    command[1] = (value >> 8) & 0xFF;
+    command[2] = value & 0xFF;
+    writeCOMMAND(command,3);
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: flush_media()
+{
+    char command[1] = "";
+    command[0] = FLUSHMEDIA;
+    writeCOMMAND(command, 1);
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: display_image(int x, int y)
+{
+    char command[6]= "";
+    command[0] = DISPLAYIMAGE;
+
+    command[1] = (x >> 8) & 0xFF;
+    command[2] = x & 0xFF;
+
+    command[3] = (y >> 8) & 0xFF;
+    command[4] = y & 0xFF;
+    writeCOMMAND(command, 5);
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: display_video(int x, int y)
+{
+    char command[5]= "";
+    command[0] = DISPLAYVIDEO;
+
+    command[1] = (x >> 8) & 0xFF;
+    command[2] = x & 0xFF;
+
+    command[3] = (y >> 8) & 0xFF;
+    command[4] = y & 0xFF;
+    writeCOMMAND(command, 5);
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: display_frame(int x, int y, int w)
+{
+    char command[7]= "";
+
+    command[0] = DISPLAYFRAME;
+
+    command[1] = (x >> 8) & 0xFF;
+    command[2] = x & 0xFF;
+
+    command[3] = (y >> 8) & 0xFF;
+    command[4] = y & 0xFF;
+
+    command[5] = (w >> 8) & 0xFF;
+    command[6] = w & 0xFF;
+    writeCOMMAND(command,7);
+}
+
+
diff -r 000000000000 -r a1c374b9a4fe 4DGL-uLCD-SE/uLCD_4DGL_Text.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/4DGL-uLCD-SE/uLCD_4DGL_Text.cpp	Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,344 @@
+//
+// uLCD_4DGL is a class to drive 4D Systems TFT touch screens
+//
+// Copyright (C) <2010> Stephane ROCHON <stephane.rochon at free.fr>
+// Modifed for Goldelox processor <2013> Jim Hamblen
+//
+// uLCD_4DGL is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// uLCD_4DGL 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with uLCD_4DGL.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "mbed.h"
+#include "uLCD_4DGL.h"
+
+//****************************************************************************************************
+void uLCD_4DGL :: set_font_size(char width, char height)     // set font size
+{
+    if (current_orientation == IS_PORTRAIT) {
+        current_fx = width;
+        current_fy = height;
+    } else {
+        current_fy = height;
+        current_fx = width;
+    }
+    max_col = current_w / (current_fx*current_wf);
+    max_row = current_h / (current_fy*current_hf);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: set_font(char mode)     // set font - system or SD media
+{
+    char command[3]= "";
+
+    command[0] = SETFONT;
+    command[1] = 0;
+    command[2] = mode;
+
+    current_font = mode;
+
+    if (current_orientation == IS_PORTRAIT) {
+        current_w = SIZE_X;
+        current_h = SIZE_Y;
+    } else {
+        current_w = SIZE_Y;
+        current_h = SIZE_X;
+    }
+
+    switch (mode) {
+        case FONT_5X7 :
+
+            current_fx = 6;
+            current_fy = 8;
+            break;
+        case FONT_7X8 :
+            current_fx = 7;
+            current_fy = 8;
+            break;
+        case FONT_8X8 :
+            current_fx = 8;
+            current_fy = 8;
+            break;
+        case FONT_8X12 :
+            current_fx = 8;
+            current_fy = 12;
+            break;
+        case FONT_12X16 :
+            current_fx = 12;
+            current_fy = 16;
+            break;
+        default:
+            current_fx = 8;
+            current_fy = 8;
+    }
+
+    max_col = current_w / (current_fx*current_wf);
+    max_row = current_h / (current_fy*current_hf);
+
+    writeCOMMAND(command, 3);
+}
+
+
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_mode(char mode)     // set text mode
+{
+    char command[3]= "";
+
+    command[0] = TEXTMODE;
+    command[1] = 0;
+    command[2] = mode;
+
+    writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_bold(char mode)     // set text mode
+{
+    char command[3]= "";
+
+    command[0] = TEXTBOLD;
+    command[1] = 0;
+    command[2] = mode;
+
+    writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_italic(char mode)     // set text mode
+{
+    char command[3]= "";
+
+    command[0] = TEXTITALIC;
+    command[1] = 0;
+    command[2] = mode;
+
+    writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_inverse(char mode)     // set text mode
+{
+    char command[3]= "";
+
+    command[0] = TEXTINVERSE;
+    command[1] = 0;
+    command[2] = mode;
+
+    writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_underline(char mode)     // set text mode
+{
+    char command[3]= "";
+
+    command[0] = TEXTUNDERLINE;
+    command[1] = 0;
+    command[2] = mode;
+
+    writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_width(char width)     // set text width
+{
+    char command[3]= "";
+
+    command[0] = TEXTWIDTH;
+    command[1] = 0;
+    command[2] = width;
+    current_wf = width;
+    max_col = current_w / (current_fx*current_wf);
+    writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_height(char height)     // set text height
+{
+    char command[3]= "";
+
+    command[0] = TEXTHEIGHT;
+    command[1] = 0;
+    command[2] = height;
+    current_hf = height;
+    max_row = current_h / (current_fy*current_hf);
+    writeCOMMAND(command, 3);
+}
+
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_char(char c, char col, char row, int color)     // draw a text char
+{
+    char command[6]= "";
+    command[0] = 0xE4; //move cursor
+    command[1] = 0;
+    command[2] = row;
+    command[3] = 0;
+    command[4] = col;
+    writeCOMMAND(command, 5);
+
+    command[0] = 0x7F;  //set color
+
+    int red5   = (color >> (16 + 3)) & 0x1F;              // get red on 5 bits
+    int green6 = (color >> (8 + 2))  & 0x3F;              // get green on 6 bits
+    int blue5  = (color >> (0 + 3))  & 0x1F;              // get blue on 5 bits
+
+    command[1] = ((red5 << 3)   + (green6 >> 3)) & 0xFF;  // first part of 16 bits color
+    command[2] = ((green6 << 5) + (blue5 >>  0)) & 0xFF;  // second part of 16 bits color
+    writeCOMMAND(command, 3);
+
+    command[0] = TEXTCHAR;  //print char
+    command[1] = 0;
+    command[2] = c;
+    writeCOMMAND(command, 3);
+
+}
+
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_string(char *s, char col, char row, char font, int color)     // draw a text string
+{
+
+    char command[1000]= "";
+    int size = strlen(s);
+    int i = 0;
+
+    set_font(font);
+
+    command[0] = 0xE4; //move cursor
+    command[1] = 0;
+    command[2] = row;
+    command[3] = 0;
+    command[4] = col;
+    writeCOMMAND(command, 5);
+
+    command[0] = 0x7F;  //set color
+    int red5   = (color >> (16 + 3)) & 0x1F;              // get red on 5 bits
+    int green6 = (color >> (8 + 2))  & 0x3F;              // get green on 6 bits
+    int blue5  = (color >> (0 + 3))  & 0x1F;              // get blue on 5 bits
+
+    command[1] = ((red5 << 3)   + (green6 >> 3)) & 0xFF;  // first part of 16 bits color
+    command[2] = ((green6 << 5) + (blue5 >>  0)) & 0xFF;  // second part of 16 bits color
+    writeCOMMAND(command, 3);
+
+    command[0] = TEXTSTRING;
+    for (i=0; i<size; i++) command[1+i] = s[i];
+    command[1+size] = 0;
+    writeCOMMANDnull(command, 2 + size);
+}
+
+
+
+//****************************************************************************************************
+void uLCD_4DGL :: locate(char col, char row)     // place text curssor at col, row
+{
+    char command[5] = "";
+    current_col = col;
+    current_row = row;
+    command[0] = MOVECURSOR; //move cursor
+    command[1] = 0;
+    command[2] = current_row;
+    command[3] = 0;
+    command[4] = current_col;
+    writeCOMMAND(command, 5);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: color(int color)     // set text color
+{
+    char command[5] = "";
+    current_color = color;
+    command[0] = 0x7F;  //set color
+
+    int red5   = (color >> (16 + 3)) & 0x1F;              // get red on 5 bits
+    int green6 = (color >> (8 + 2))  & 0x3F;              // get green on 6 bits
+    int blue5  = (color >> (0 + 3))  & 0x1F;              // get blue on 5 bits
+
+    command[1] = ((red5 << 3)   + (green6 >> 3)) & 0xFF;  // first part of 16 bits color
+    command[2] = ((green6 << 5) + (blue5 >>  0)) & 0xFF;  // second part of 16 bits color
+    writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: putc(char c)      // place char at current cursor position
+//used by virtual printf function _putc
+{
+    char command[6] ="";
+    if(c<0x20) {
+        if(c=='\n') {
+            current_col = 0;
+            current_row++;
+            command[0] = MOVECURSOR; //move cursor to start of next line
+            command[1] = 0;
+            command[2] = current_row;
+            command[3] = 0;
+            command[4] = current_col;
+            writeCOMMAND(command, 5);
+        }
+        if(c=='\r') {
+            current_col = 0;
+            command[0] = MOVECURSOR; //move cursor to start of line
+            command[1] = 0;
+            command[2] = current_row;
+            command[3] = 0;
+            command[4] = current_col;
+            writeCOMMAND(command, 5);
+        }
+        if(c=='\f') {
+            uLCD_4DGL::cls(); //clear screen on form feed
+        }
+    } else {
+        command[0] = PUTCHAR;
+        command[1] = 0x00;
+        command[2] = c;
+        writeCOMMAND(command,3);
+        current_col++;
+    }
+    if (current_col == max_col) {
+        current_col = 0;
+        current_row++;
+        command[0] = MOVECURSOR; //move cursor to next line
+        command[1] = 0;
+        command[2] = current_row;
+        command[3] = 0;
+        command[4] = current_col;
+        writeCOMMAND(command, 5);
+    }
+    if (current_row == max_row) {
+        current_row = 0;
+        command[0] = MOVECURSOR; //move cursor back to start
+        command[1] = 0;
+        command[2] = current_row;
+        command[3] = 0;
+        command[4] = current_col;
+        writeCOMMAND(command, 5);
+    }
+}
+
+
+//****************************************************************************************************
+void uLCD_4DGL :: puts(char *s)     // place string at current cursor position
+{
+
+    text_string(s, current_col, current_row, current_font, current_color);
+
+    current_col += strlen(s);
+
+    if (current_col >= max_col) {
+        current_row += current_col / max_col;
+        current_col %= max_col;
+    }
+    if (current_row >= max_row) {
+        current_row %= max_row;
+    }
+}
+
diff -r 000000000000 -r a1c374b9a4fe 4DGL-uLCD-SE/uLCD_4DGL_main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/4DGL-uLCD-SE/uLCD_4DGL_main.cpp	Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,470 @@
+//
+// uLCD_4DGL is a class to drive 4D Systems uLCD 144 G2
+//
+// Copyright (C) <2010> Stephane ROCHON <stephane.rochon at free.fr>
+// Modifed for Goldelox processor <2013> Jim Hamblen
+//
+// uLCD_4DGL is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// uLCD_4DGL 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with uLCD_4DGL.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "mbed.h"
+#include "uLCD_4DGL.h"
+
+#define ARRAY_SIZE(X) sizeof(X)/sizeof(X[0])
+
+//Serial pc(USBTX,USBRX);
+
+
+//******************************************************************************************************
+uLCD_4DGL :: uLCD_4DGL(PinName tx, PinName rx, PinName rst) : _cmd(tx, rx),
+    _rst(rst)
+#if DEBUGMODE
+    ,pc(USBTX, USBRX)
+#endif // DEBUGMODE
+{
+    // Constructor
+    _cmd.baud(9600);
+#if DEBUGMODE
+    pc.baud(115200);
+
+    pc.printf("\n\n\n");
+    pc.printf("*********************\n");
+    pc.printf("uLCD_4DGL CONSTRUCTOR\n");
+    pc.printf("*********************\n");
+#endif
+
+    _rst = 1;    // put RESET pin to high to start TFT screen
+    reset();
+    cls();       // clear screen
+    current_col         = 0;            // initial cursor col
+    current_row         = 0;            // initial cursor row
+    current_color       = WHITE;        // initial text color
+    current_orientation = IS_PORTRAIT;  // initial screen orientation
+    current_hf = 1;
+    current_wf = 1;
+    set_font(FONT_7X8);                 // initial font
+//   text_mode(OPAQUE);                  // initial texr mode
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: writeBYTE(char c)   // send a BYTE command to screen
+{
+
+    _cmd.putc(c);
+    wait_us(500);  //mbed is too fast for LCD at high baud rates in some long commands
+
+#if DEBUGMODE
+    pc.printf("   Char sent : 0x%02X\n",c);
+#endif
+
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: writeBYTEfast(char c)   // send a BYTE command to screen
+{
+
+    _cmd.putc(c);
+    //wait_ms(0.0);  //mbed is too fast for LCD at high baud rates - but not in short commands
+
+#if DEBUGMODE
+    pc.printf("   Char sent : 0x%02X\n",c);
+#endif
+
+}
+//******************************************************************************************************
+void uLCD_4DGL :: freeBUFFER(void)         // Clear serial buffer before writing command
+{
+
+    while (_cmd.readable()) _cmd.getc();  // clear buffer garbage
+}
+
+//******************************************************************************************************
+int uLCD_4DGL :: writeCOMMAND(char *command, int number)   // send several BYTES making a command and return an answer
+{
+
+#if DEBUGMODE
+    pc.printf("\n");
+    pc.printf("New COMMAND : 0x%02X\n", command[0]);
+#endif
+    int i, resp = 0;
+    freeBUFFER();
+    writeBYTE(0xFF);
+    for (i = 0; i < number; i++) {
+        if (i<16)
+            writeBYTEfast(command[i]); // send command to serial port
+        else
+            writeBYTE(command[i]); // send command to serial port but slower
+    }
+    while (!_cmd.readable()) wait_ms(TEMPO);              // wait for screen answer
+    if (_cmd.readable()) resp = _cmd.getc();           // read response if any
+    switch (resp) {
+        case ACK :                                     // if OK return   1
+            resp =  1;
+            break;
+        case NAK :                                     // if NOK return -1
+            resp = -1;
+            break;
+        default :
+            resp =  0;                                 // else return   0
+            break;
+    }
+#if DEBUGMODE
+    pc.printf("   Answer received : %d\n",resp);
+#endif
+
+    return resp;
+}
+
+//**************************************************************************
+void uLCD_4DGL :: reset()    // Reset Screen
+{
+    wait_ms(5);
+    _rst = 0;               // put RESET pin to low
+    wait_ms(5);         // wait a few milliseconds for command reception
+    _rst = 1;               // put RESET back to high
+    wait(3);                // wait 3s for screen to restart
+
+    freeBUFFER();           // clean buffer from possible garbage
+}
+//******************************************************************************************************
+int uLCD_4DGL :: writeCOMMANDnull(char *command, int number)   // send several BYTES making a command and return an answer
+{
+
+#if DEBUGMODE
+    pc.printf("\n");
+    pc.printf("New COMMAND : 0x%02X\n", command[0]);
+#endif
+    int i, resp = 0;
+    freeBUFFER();
+    writeBYTE(0x00); //command has a null prefix byte
+    for (i = 0; i < number; i++) {
+        if (i<16) //don't overflow LCD UART buffer
+            writeBYTEfast(command[i]); // send command to serial port
+        else
+            writeBYTE(command[i]); // send command to serial port with delay
+    }
+    while (!_cmd.readable()) wait_ms(TEMPO);              // wait for screen answer
+    if (_cmd.readable()) resp = _cmd.getc();           // read response if any
+    switch (resp) {
+        case ACK :                                     // if OK return   1
+            resp =  1;
+            break;
+        case NAK :                                     // if NOK return -1
+            resp = -1;
+            break;
+        default :
+            resp =  0;                                 // else return   0
+            break;
+    }
+#if DEBUGMODE
+    pc.printf("   Answer received : %d\n",resp);
+#endif
+
+    return resp;
+}
+
+//**************************************************************************
+void uLCD_4DGL :: cls()    // clear screen
+{
+    char command[1] = "";
+
+    command[0] = CLS;
+    writeCOMMAND(command, 1);
+    current_row=0;
+    current_col=0;
+    current_hf = 1;
+    current_wf = 1;
+    set_font(FONT_7X8);                 // initial font
+}
+
+//**************************************************************************
+int uLCD_4DGL :: version()    // get API version
+{
+
+    char command[2] = "";
+    command[0] = '\x00';
+    command[1] = VERSION;
+    return readVERSION(command, 2);
+}
+
+//**************************************************************************
+void uLCD_4DGL :: baudrate(int speed)    // set screen baud rate
+{
+    char command[3]= "";
+    writeBYTE(0x00);
+    command[0] = BAUDRATE;
+    command[1] = 0;
+    int newbaud = BAUD_9600;
+    switch (speed) {
+        case  110 :
+            newbaud = BAUD_110;
+            break;
+        case  300 :
+            newbaud = BAUD_300;
+            break;
+        case  600 :
+            newbaud = BAUD_600;
+            break;
+        case 1200 :
+            newbaud = BAUD_1200;
+            break;
+        case 2400 :
+            newbaud = BAUD_2400;
+            break;
+        case 4800 :
+            newbaud = BAUD_4800;
+            break;
+        case 9600 :
+            newbaud = BAUD_9600;
+            break;
+        case 14400 :
+            newbaud = BAUD_14400;
+            break;
+        case 19200 :
+            newbaud = BAUD_19200;
+            break;
+        case 31250 :
+            newbaud = BAUD_31250;
+            break;
+        case 38400 :
+            newbaud = BAUD_38400;
+            break;
+        case 56000 :
+            newbaud = BAUD_56000;
+            break;
+        case 57600 :
+            newbaud = BAUD_57600;
+            break;
+        case 115200 :
+            newbaud = BAUD_115200;
+            break;
+        case 128000 :
+            newbaud = BAUD_128000;
+            break;
+        case 256000 :
+            newbaud = BAUD_256000;
+            break;
+        case 300000 :
+            newbaud = BAUD_300000;
+            speed = 272727;
+            break;
+        case 375000 :
+            newbaud = BAUD_375000;
+            speed = 333333;
+            break;
+        case 500000 :
+            newbaud = BAUD_500000;
+            speed = 428571;
+            break;
+        case 600000 :
+            newbaud = BAUD_600000;
+            break;
+        case 750000 : //rates over 600000 are not documented, but seem to work
+            newbaud = BAUD_750000;
+            break;
+        case 1000000 :  
+            newbaud = BAUD_1000000;
+            break;
+        case 1500000 :
+            newbaud = BAUD_1500000;
+            break;
+        case 3000000 :
+            newbaud = BAUD_3000000;
+            break;
+        default   :
+            newbaud = BAUD_9600;
+            speed = 9600;
+            break;
+    }
+
+    int i, resp = 0;
+
+    freeBUFFER();
+    command[1] = char(newbaud >>8);
+    command[2] = char(newbaud % 256);
+    wait_ms(1);
+    for (i = 0; i <3; i++) writeBYTEfast(command[i]);      // send command to serial port
+    for (i = 0; i<10; i++) wait_ms(1); 
+    //dont change baud until all characters get sent out
+    _cmd.baud(speed);                                  // set mbed to same speed
+    i=0;
+    while ((!_cmd.readable()) && (i<25000)) {
+        wait_ms(TEMPO);           // wait for screen answer - comes 100ms after change
+        i++; //timeout if ack character missed by baud change
+    }
+    if (_cmd.readable()) resp = _cmd.getc();           // read response if any
+    switch (resp) {
+        case ACK :                                     // if OK return   1
+            resp =  1;
+            break;
+        case NAK :                                     // if NOK return -1
+            resp = -1;
+            break;
+        default :
+            resp =  0;                                 // else return   0
+            break;
+    }
+}
+
+//******************************************************************************************************
+int uLCD_4DGL :: readVERSION(char *command, int number)   // read screen info and populate data
+{
+
+    int i, temp = 0, resp = 0;
+    char response[5] = "";
+
+    freeBUFFER();
+
+    for (i = 0; i < number; i++) writeBYTE(command[i]);    // send all chars to serial port
+
+    while (!_cmd.readable()) wait_ms(TEMPO);               // wait for screen answer
+
+    while (_cmd.readable() && resp < ARRAY_SIZE(response)) {
+        temp = _cmd.getc();
+        response[resp++] = (char)temp;
+    }
+    switch (resp) {
+        case 2 :                                           // if OK populate data and return 1
+            revision  = response[0]<<8 + response[1];
+            resp      = 1;
+            break;
+        default :
+            resp =  0;                                     // else return 0
+            break;
+    }
+    return resp;
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: background_color(int color)              // set screen background color
+{
+    char command[3]= "";                                  // input color is in 24bits like 0xRRGGBB
+
+    command[0] = BCKGDCOLOR;
+
+    int red5   = (color >> (16 + 3)) & 0x1F;              // get red on 5 bits
+    int green6 = (color >> (8 + 2))  & 0x3F;              // get green on 6 bits
+    int blue5  = (color >> (0 + 3))  & 0x1F;              // get blue on 5 bits
+
+    command[1] = ((red5 << 3)   + (green6 >> 3)) & 0xFF;  // first part of 16 bits color
+    command[2] = ((green6 << 5) + (blue5 >>  0)) & 0xFF;  // second part of 16 bits color
+
+    writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: textbackground_color(int color)              // set screen background color
+{
+    char command[3]= "";                                  // input color is in 24bits like 0xRRGGBB
+
+    command[0] = TXTBCKGDCOLOR;
+
+    int red5   = (color >> (16 + 3)) & 0x1F;              // get red on 5 bits
+    int green6 = (color >> (8 + 2))  & 0x3F;              // get green on 6 bits
+    int blue5  = (color >> (0 + 3))  & 0x1F;              // get blue on 5 bits
+
+    command[1] = ((red5 << 3)   + (green6 >> 3)) & 0xFF;  // first part of 16 bits color
+    command[2] = ((green6 << 5) + (blue5 >>  0)) & 0xFF;  // second part of 16 bits color
+
+    writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: display_control(char mode)     // set screen mode to value
+{
+    char command[3]= "";
+
+    command[0] = DISPCONTROL;
+    command[1] = 0;
+    command[2] = mode;
+
+    if (mode ==  ORIENTATION) {
+        switch (mode) {
+            case LANDSCAPE :
+                current_orientation = IS_LANDSCAPE;
+                break;
+            case LANDSCAPE_R :
+                current_orientation = IS_LANDSCAPE;
+                break;
+            case PORTRAIT :
+                current_orientation = IS_PORTRAIT;
+                break;
+            case PORTRAIT_R :
+                current_orientation = IS_PORTRAIT;
+                break;
+        }
+    }
+    writeCOMMAND(command, 3);
+    set_font(current_font);
+}
+//****************************************************************************************************
+void uLCD_4DGL :: display_power(char mode)     // set screen mode to value
+{
+    char command[3]= "";
+
+    command[0] = DISPPOWER;
+    command[1] = 0;
+    command[2] = mode;
+    writeCOMMAND(command, 3);
+}
+//****************************************************************************************************
+void uLCD_4DGL :: set_volume(char value)     // set sound volume to value
+{
+    char command[2]= "";
+
+    command[0] = SETVOLUME;
+    command[1] = value;
+
+    writeCOMMAND(command, 2);
+}
+
+
+//******************************************************************************************************
+int uLCD_4DGL :: getSTATUS(char *command, int number)   // read screen info and populate data
+{
+
+#if DEBUGMODE
+    pc.printf("\n");
+    pc.printf("New COMMAND : 0x%02X\n", command[0]);
+#endif
+
+    int i, temp = 0, resp = 0;
+    char response[5] = "";
+
+    freeBUFFER();
+
+    for (i = 0; i < number; i++) writeBYTE(command[i]);    // send all chars to serial port
+
+    while (!_cmd.readable()) wait_ms(TEMPO);    // wait for screen answer
+
+    while (_cmd.readable() && resp < ARRAY_SIZE(response)) {
+        temp = _cmd.getc();
+        response[resp++] = (char)temp;
+    }
+    switch (resp) {
+        case 4 :
+            resp = (int)response[1];         // if OK populate data
+            break;
+        default :
+            resp =  -1;                      // else return   0
+            break;
+    }
+
+#if DEBUGMODE
+    pc.printf("   Answer received : %d\n", resp);
+#endif
+
+    return resp;
+}
+
+
diff -r 000000000000 -r a1c374b9a4fe SDFileSystem.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SDFileSystem.lib	Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,1 @@
+http://developer.mbed.org/users/mbed_official/code/SDFileSystem/#7b35d1709458
diff -r 000000000000 -r a1c374b9a4fe SongPlayer.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SongPlayer.h	Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,52 @@
+#include "mbed.h"
+// new class to play a note on Speaker based on PwmOut class
+class SongPlayer
+{
+public:
+    SongPlayer(PinName pin) : _pin(pin) {
+// _pin(pin) means pass pin to the constructor
+    }
+// class method to play a note based on PwmOut class
+    void PlaySong(float frequency[], float duration[], float volume=1.0) {
+        vol = volume;
+        notecount = 0;
+        _pin.period(1.0/frequency[notecount]);
+        _pin = volume/2.0;
+        noteduration.attach(this,&SongPlayer::nextnote, duration[notecount]);
+        // setup timer to interrupt for next note to play
+        frequencyptr = frequency;
+        durationptr = duration;
+        //returns after first note starts to play
+    }
+    void PlaySong1(float *frequency, float *duration, float volume=1.0) {
+        vol = volume;
+        notecount = 0;
+        _pin.period(1.0/(*frequency));
+        _pin = volume/2.0;
+        noteduration.attach(this,&SongPlayer::nextnote, *duration);
+        // setup timer to interrupt for next note to play
+        frequencyptr = frequency;
+        durationptr = duration;
+        //returns after first note starts to play
+    }
+    void nextnote();
+private:
+    Timeout noteduration;
+    PwmOut _pin;
+    int notecount;
+    float vol;
+    float * frequencyptr;
+    float * durationptr;
+};
+//Interrupt Routine to play next note
+void SongPlayer::nextnote()
+{
+    _pin = 0.0;
+    notecount++; //setup next note in song
+    if (durationptr[notecount]!=0.0) {
+        _pin.period(1.0/frequencyptr[notecount]);
+        noteduration.attach(this,&SongPlayer::nextnote, durationptr[notecount]);
+        _pin = vol/2.0;
+    } else
+        _pin = 0.0; //turn off on last note
+}
diff -r 000000000000 -r a1c374b9a4fe main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,397 @@
+//ECE 4180 Piano Tiles
+//Spring 2016 Georgia Tech
+//Kushagra Brahmbhatt
+//Christopher Lu
+
+#include "mbed.h"
+#include "uLCD_4DGL.h"
+#include <mpr121.h>
+#include "SongPlayer.h"
+#include "SDFileSystem.h"
+#include "wave_player.h"
+
+//LCD better
+uLCD_4DGL uLCD(p28,p27,p29);
+
+//Speaker 
+SongPlayer mySpeaker(p21);
+AnalogOut Speaker(p18); 
+
+// Setup the i2c bus on pins 9 and 10
+I2C i2c(p9, p10);
+
+// Setup the Mpr121:
+// Create the interrupt receiver object on pin 26
+InterruptIn interrupt(p26);
+// constructor(i2c object, i2c address of the mpr121)
+Mpr121 mpr121(&i2c, Mpr121::ADD_VSS);
+
+// the pinout on the mbed Cool Components workshop board
+SDFileSystem sd(p5, p6, p7, p8, "sd"); 
+
+//timer
+Timer t;
+
+//bool key0Press, key4Press, key8Press;
+int vals;
+bool interruptBool;
+int score, timer;
+
+// Key hit/release interrupt routine
+void fallInterrupt() { //void
+
+  int value=mpr121.read(0x00);
+  
+  //wait(2);
+  value +=mpr121.read(0x01)<<8;
+  interruptBool = true;
+  vals = value;
+}  
+
+
+int press() {
+    int value=mpr121.read(0x00);
+    value +=mpr121.read(0x01)<<8;
+    //1(key 0)  2(key 1)  4  8  16 32 64 128 256 512 1024 2048(key 11)
+    return value;
+}
+
+bool check(int value) {
+    if (value == 1) { //key0
+        if(uLCD.read_pixel(15,90)==BLACK) {
+            return true;    
+        }
+    }
+    if (value == 16) { //key4
+        if(uLCD.read_pixel(50,90)==BLACK) {
+            return true;    
+        }
+    }
+    if (value == 256) { //key8
+        if(uLCD.read_pixel(90,90)==BLACK) {
+            return true;    
+        }    
+    }
+    return false;
+}
+
+//initialize the graphics for the game
+void startGame(){
+    uLCD.background_color(WHITE);
+    uLCD.cls();
+    //draw walls 
+    uLCD.filled_rectangle(0,103,10,0, BLUE);
+    uLCD.filled_rectangle(117,103,127,0, BLUE); 
+    uLCD.filled_rectangle(10,78,117,103, 0xFDF983);
+    uLCD.locate(0,13);
+    uLCD.textbackground_color(WHITE);
+    uLCD.color(RED);
+    uLCD.printf("Score: "); 
+    uLCD.locate(9,13);
+    uLCD.printf("Time:");
+    uLCD.locate(4,14);
+    uLCD.text_width(1); //4X size text
+    uLCD.text_height(2);
+    uLCD.printf("Piano Tiles");
+    
+     
+    //draw the lines
+    uLCD.line(10, 26, 117, 26, BLACK);
+    uLCD.line(10, 52, 117, 52, BLACK);
+    uLCD.line(10, 78, 117, 78, BLACK);
+    uLCD.line(10, 103, 117, 103, BLACK);
+    
+    uLCD.line(46, 0, 46, 103, BLACK);
+    uLCD.line(82, 0, 82, 103, BLACK);
+    
+}
+
+//moves block down
+int updateBlockY1(int y) {
+    y = y + 26;
+    if (y > 81) {
+        y = 3;
+    }
+    return y;
+}
+
+int updateBlockY2(int y) {
+    y = y + 26;
+    if (y > 101) {
+        y = 23;
+    }
+    return y;
+}
+
+//Frequency of notes for Fur Elise 
+float note[85]= {329.63,311.13,329.63,311.13,329.63,246.94,293.66,261.63,220.00,
+                 146.83,174.61,220.0,246.94,174.61,233.08,246.94,261.63, 329.63, 
+                 311.13, 329.63, 246.94, 293.66, 261.63, 220.00, 146.83, 174.61, 
+                 220.00, 246.94, 174.61, 261.63, 246.94, 220.00, 246.94, 261.63, 
+                 293.66, 329.63, 196.00, 329.23, 329.23, 293.63, 164.81, 329.63, 
+                 293.63, 261.63, 146.83, 293.63, 261.63, 246.94, 329.63, 311.13, 
+                 329.63, 311.13, 329.63, 246.94, 293.66, 261.63, 220.00, 146.83, 
+                 174.61, 220.00, 246.94, 174.61, 233.08, 246.94, 261.63, 329.63, 
+                 311.13, 329.63, 311.13, 329.63, 311.13, 329.63, 246.94, 293.66, 
+                 261.63, 220.00, 146.83, 174.61, 220.00, 246.94, 174.61, 261.63, 
+                 246.94, 220.0, 0.0};
+//How long each note plays for
+float duration[85]= {0.3,0.3,0.3,0.3,0.30,0.30,0.30,0.30,0.30,
+                     0.30,0.30,0.30,0.30,0.30,0.30,0.30,0.30,
+                     0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 
+                     0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 
+                     0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 
+                     0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 
+                     0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 
+                     0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 
+                     0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 
+                     0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 
+                     0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 
+                     0.30, 0.30, 0.30, 0.30, 0.0};
+
+
+int main() {
+    
+    //wait 4 seconds then moves on to graphics of the game
+    uLCD.locate(3,4);
+    uLCD.text_width(1); 
+    uLCD.text_height(2);
+    uLCD.printf("Piano Tiles!!!\n");
+    uLCD.text_height(1);
+    uLCD.locate(5,8);
+    uLCD.printf("Playing:");
+    uLCD.locate(5,9);
+    uLCD.printf("Beethoven");
+    uLCD.locate(5,10);
+    uLCD.printf("Fur Elise");
+    uLCD.locate(0,12);
+    uLCD.printf("Get a score above ");
+    uLCD.locate(4,13);
+    uLCD.printf("100 to win!");
+    wait(4);
+    
+    interrupt.fall(&fallInterrupt);
+    interrupt.mode(PullUp);
+    startGame();
+    
+    //initialization to track tiles
+    int a[16];
+    int y1 = 81; //starting y coordinate to fill in rectangle from the bottom
+    int y2 = 101;
+    int position = 1; //tracks placement of the previous tile for tone so tiles are placed by tones
+    
+    
+    //initializing the first four set of piano tiles
+    for (int i = 0; i < 4; i++) {
+        if (note[i] < note[i-1] && i != 0){    //if (note<previousnote) then next tile is to the left
+            uLCD.filled_rectangle(49,y1,79,y2, BLACK);
+            a[4*i + 0] = 49;
+            a[4*i + 1] = y1;
+            a[4*i + 2] = 79;
+            a[4*i + 3] = y2; 
+            position = 2;
+        } 
+        else if (i == 0 || note[i] > note[i-1]) {    //initial start is on right side of screen
+            uLCD.filled_rectangle(85,y1,115,y2, BLACK);
+            a[4*i + 0] = 85;
+            a[4*i + 1] = y1;
+            a[4*i + 2] = 115;
+            a[4*i + 3] = y2; 
+            position = 3;
+        }
+        //move from bottom of the screen to the top
+        y1 = y1 - 26; 
+        y2 = y2 - 26;
+    }
+    //array used for holding all the tiles
+    int block1_x1 = a[0];
+    int block1_y1 = a[1];
+    int block1_x2 = a[2];
+    int block1_y2 = a[3];
+    int block2_x1 = a[4];
+    int block2_y1 = a[5];
+    int block2_x2 = a[6];
+    int block2_y2 = a[7];
+    int block3_x1 = a[8];
+    int block3_y1 = a[9];
+    int block3_x2 = a[10];
+    int block3_y2 = a[11];
+    int block4_x1 = a[12];
+    int block4_y1 = a[13];
+    int block4_x2 = a[14];
+    int block4_y2 = a[15];
+
+    t.start();
+    
+    //starting the game
+    while(1) {
+        if (interruptBool) { //key is pressed
+        uLCD.locate(0,0);
+        bool checkTrue = check(vals);
+        uLCD.locate(0,0);
+
+        if (checkTrue) { //if right correct key is pressed, tiles are replaced and move down
+            uLCD.filled_rectangle(block1_x1, block1_y1, block1_x2, block1_y2, WHITE);
+            uLCD.filled_rectangle(block2_x1, block2_y1, block2_x2, block2_y2, WHITE);
+            uLCD.filled_rectangle(block3_x1, block3_y1, block3_x2, block3_y2, WHITE);
+            uLCD.filled_rectangle(block4_x1, block4_y1, block4_x2, block4_y2, WHITE);
+            block1_y1 = updateBlockY1(block1_y1);
+            block1_y2 = updateBlockY2(block1_y2);
+            block2_y1 = updateBlockY1(block2_y1);
+            block2_y2 = updateBlockY2(block2_y2);
+            block3_y1 = updateBlockY1(block3_y1);
+            block3_y2 = updateBlockY2(block3_y2);
+            block4_y1 = updateBlockY1(block4_y1);
+            block4_y2 = updateBlockY2(block4_y2);
+            
+            //the following if statements determine position of the following tiles based on the
+            //frequencies of the note that is being played
+            if(block1_y1 == 3) 
+            {
+                if (note[score%85+4] < note[score%85+3] && (position == 1 || position == 2)) {
+                    block1_x1 = 13;
+                    block1_x2 = 43;
+                    position = 1;
+                } else if ((note[score%85+4] < note[score%85+3] && position == 3) || (note[score%85+4] > note[score%85+3] && position == 1 )) {
+                    block1_x1 = 49;
+                    block1_x2 = 79;  
+                    position = 2;
+                } else if (note[score%85+4] > note[score%85+3] && (position == 2 || position == 3))  {
+                    block1_x1 = 85;
+                    block1_x2 = 115;  
+                    position = 3;
+                }
+            }
+            if(block2_y1 == 3) 
+            {
+                if (note[score%85+4] < note[score%85+3] && (position == 1 || position == 2)) {
+                    block2_x1 = 13;
+                    block2_x2 = 43;
+                    position = 1;
+                } else if ((note[score%85+4] < note[score%85+3] && position == 3) || (note[score%85+4] > note[score%85+3] && position == 1 )) {
+                    block2_x1 = 49;
+                    block2_x2 = 79;  
+                    position = 2;
+                } else if (note[score%85+4] > note[score%85+3] && (position == 2 || position == 3))  {
+                    block2_x1 = 85;
+                    block2_x2 = 115;  
+                    position = 3;
+                }
+            }
+            if(block3_y1 == 3) 
+            {
+                if (note[score%85+4] < note[score%85+3] && (position == 1 || position == 2)) {
+                    block3_x1 = 13;
+                    block3_x2 = 43;
+                    position = 1;
+                } else if ((note[score%85+4] < note[score%85+3] && position == 3) || (note[score%85+4] > note[score%85+3] && position == 1 )) {
+                    block3_x1 = 49;
+                    block3_x2 = 79;  
+                    position = 2;
+                } else if (note[score%85+4] > note[score%85+3] && (position == 2 || position == 3))  {
+                    block3_x1 = 85;
+                    block3_x2 = 115;  
+                    position = 3;
+                }
+            }
+            if(block4_y1 == 3) 
+            {
+                if (note[score%85+4] < note[score%85+3] && (position == 1 || position == 2)) {
+                    block4_x1 = 13;
+                    block4_x2 = 43;
+                    position = 1;
+                } else if ((note[score%85+4] < note[score%85+3] && position == 3) || (note[score%85+4] > note[score%85+3] && position == 1 )) {
+                    block4_x1 = 49;
+                    block4_x2 = 79;  
+                    position = 2;
+                } else if (note[score%85+4] > note[score%85+3] && (position == 2 || position == 3))  {
+                    block4_x1 = 85;
+                    block4_x2 = 115;  
+                    position = 3;
+                }
+            }
+            
+            //fill in the tiles
+            uLCD.filled_rectangle(block1_x1, block1_y1, block1_x2, block1_y2, BLACK);
+            uLCD.filled_rectangle(block2_x1, block2_y1, block2_x2, block2_y2, BLACK);
+            uLCD.filled_rectangle(block3_x1, block3_y1, block3_x2, block3_y2, BLACK);
+            uLCD.filled_rectangle(block4_x1, block4_y1, block4_x2, block4_y2, BLACK);
+            interruptBool = false;
+            
+            //plays the note as the keypad is being pressed
+            float note1[] = {note[score%85]};
+            float duration1[] = {duration[score%85]};
+            mySpeaker.PlaySong(note1,duration1);
+            score++;
+            
+            //updates the time and score
+            uLCD.text_width(1);
+            uLCD.text_height(1);
+            uLCD.locate(0,13);
+            uLCD.textbackground_color(WHITE);
+            uLCD.color(RED);
+            uLCD.printf("Score:%d", score); 
+            uLCD.locate(9,13);
+            uLCD.printf("Time:%0.1f", t.read());
+
+            
+        } 
+        else { //while loop breaks when the wrong key is pressed
+            break;
+            //Game Over Screen outside while loop    
+            }
+        } //end of interruptBool
+    }//end of while loop
+    
+
+        //win or lose music
+        wave_player waver(&Speaker);
+        //vector<string> filenames; //filenames are stored in a vector string
+        bool  PLAY = true;
+        bool  *PlayStopPtr = &PLAY;
+        FILE *wave_file;
+ 
+ //victory and game over screen
+    if (score >= 100)
+    {
+        uLCD.cls();
+        uLCD.locate(0,4);
+        uLCD.text_width(2); //4X size text
+        uLCD.text_height(2);
+        uLCD.printf("Victory!!");
+        uLCD.text_width(1); //4X size text
+        uLCD.text_height(1);
+        uLCD.locate(4,7);
+        uLCD.printf("SCORE:%d", score);
+        t.stop();
+        uLCD.locate(4,8);
+        uLCD.printf("Time:%0.2f", t.read());
+        uLCD.locate(0,10);
+        uLCD.printf("Thanks for playing");
+        
+        FILE *wave_file;
+        wave_file=fopen("/sd/wavfiles/victory.wav","r");
+        waver.play(wave_file,PlayStopPtr);
+    }
+    else
+    {
+        uLCD.cls();
+        uLCD.locate(0,4);
+        uLCD.text_width(2); //4X size text
+        uLCD.text_height(2);
+        uLCD.printf("Game Over");
+        uLCD.text_width(1); //4X size text
+        uLCD.text_height(1);
+        uLCD.locate(4,7);
+        uLCD.printf("SCORE:%d", score);
+        t.stop();
+        uLCD.locate(4,8);
+        uLCD.printf("Time:%0.2f", t.read());
+        uLCD.locate(0,10);
+        uLCD.printf("Thanks for playing");
+        
+        FILE *wave_file;
+        wave_file=fopen("/sd/wavfiles/defeat.wav","r");
+        waver.play(wave_file,PlayStopPtr);
+    }
+}
diff -r 000000000000 -r a1c374b9a4fe mbed.bld
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,1 @@
+http://world3.dev.mbed.org/users/mbed_official/code/mbed/builds/824293ae5e43
\ No newline at end of file
diff -r 000000000000 -r a1c374b9a4fe mpr121/mpr121.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mpr121/mpr121.cpp	Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,221 @@
+/*
+Copyright (c) 2011 Anthony Buckton (abuckton [at] blackink [dot} net {dot} au)
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#include <mbed.h>
+#include <sstream>
+#include <string>
+#include <list>
+
+#include <mpr121.h>
+    
+Mpr121::Mpr121(I2C *i2c, Address i2cAddress)
+{
+    this->i2c = i2c;
+    
+    address = i2cAddress;
+           
+    // Configure the MPR121 settings to default
+    this->configureSettings();
+}
+
+   
+void Mpr121::configureSettings()
+{
+    // Put the MPR into setup mode
+    this->write(ELE_CFG,0x00);
+    
+    // Electrode filters for when data is > baseline
+    unsigned char gtBaseline[] = {
+         0x01,  //MHD_R
+         0x01,  //NHD_R 
+         0x00,  //NCL_R
+         0x00   //FDL_R
+         };
+         
+    writeMany(MHD_R,gtBaseline,4);   
+                 
+     // Electrode filters for when data is < baseline   
+     unsigned char ltBaseline[] = {
+        0x01,   //MHD_F
+        0x01,   //NHD_F
+        0xFF,   //NCL_F
+        0x02    //FDL_F
+        };
+        
+    writeMany(MHD_F,ltBaseline,4);
+        
+    // Electrode touch and release thresholds
+    unsigned char electrodeThresholds[] = {
+        E_THR_T, // Touch Threshhold
+        E_THR_R  // Release Threshold
+        };
+
+    for(int i=0; i<12; i++){
+        int result = writeMany((ELE0_T+(i*2)),electrodeThresholds,2);
+    }   
+
+    // Proximity Settings
+    unsigned char proximitySettings[] = {
+        0xff,   //MHD_Prox_R
+        0xff,   //NHD_Prox_R
+        0x00,   //NCL_Prox_R
+        0x00,   //FDL_Prox_R
+        0x01,   //MHD_Prox_F
+        0x01,   //NHD_Prox_F
+        0xFF,   //NCL_Prox_F
+        0xff,   //FDL_Prox_F
+        0x00,   //NHD_Prox_T
+        0x00,   //NCL_Prox_T
+        0x00    //NFD_Prox_T
+        };
+    writeMany(MHDPROXR,proximitySettings,11);
+
+    unsigned char proxThresh[] = {
+        PROX_THR_T, // Touch Threshold
+        PROX_THR_R  // Release Threshold
+        };
+    writeMany(EPROXTTH,proxThresh,2); 
+       
+    this->write(FIL_CFG,0x04);
+    
+    // Set the electrode config to transition to active mode
+    this->write(ELE_CFG,0x0c);
+}
+
+void Mpr121::setElectrodeThreshold(int electrode, unsigned char touch, unsigned char release){
+    
+    if(electrode > 11) return;
+    
+    // Get the current mode
+    unsigned char mode = this->read(ELE_CFG);
+    
+    // Put the MPR into setup mode
+    this->write(ELE_CFG,0x00);
+    
+    // Write the new threshold
+    this->write((ELE0_T+(electrode*2)), touch);
+    this->write((ELE0_T+(electrode*2)+1), release);
+    
+    //Restore the operating mode
+    this->write(ELE_CFG, mode);
+}
+    
+    
+unsigned char Mpr121::read(int key){
+
+    unsigned char data[2];
+    
+    //Start the command
+    i2c->start();
+
+    // Address the target (Write mode)
+    int ack1= i2c->write(address);
+
+    // Set the register key to read
+    int ack2 = i2c->write(key);
+
+    // Re-start for read of data
+    i2c->start();
+
+    // Re-send the target address in read mode
+    int ack3 = i2c->write(address+1);
+
+    // Read in the result
+    data[0] = i2c->read(0); 
+
+    // Reset the bus        
+    i2c->stop();
+
+    return data[0];
+}
+
+
+int Mpr121::write(int key, unsigned char value){
+    
+    //Start the command
+    i2c->start();
+
+    // Address the target (Write mode)
+    int ack1= i2c->write(address);
+
+    // Set the register key to write
+    int ack2 = i2c->write(key);
+
+    // Read in the result
+    int ack3 = i2c->write(value); 
+
+    // Reset the bus        
+    i2c->stop();
+    
+    return (ack1+ack2+ack3)-3;
+}
+
+
+int Mpr121::writeMany(int start, unsigned char* dataSet, int length){
+    //Start the command
+    i2c->start();
+
+    // Address the target (Write mode)
+    int ack= i2c->write(address);
+    if(ack!=1){
+        return -1;
+    }
+    
+    // Set the register key to write
+    ack = i2c->write(start);
+    if(ack!=1){
+        return -1;
+    }
+
+    // Write the date set
+    int count = 0;
+    while(ack==1 && (count < length)){
+        ack = i2c->write(dataSet[count]);
+        count++;
+    } 
+    // Stop the cmd
+    i2c->stop();
+    
+    return count;
+}
+      
+
+bool Mpr121::getProximityMode(){
+    if(this->read(ELE_CFG) > 0x0c)
+        return true;
+    else
+        return false;
+}
+
+void Mpr121::setProximityMode(bool mode){
+    this->write(ELE_CFG,0x00);
+    if(mode){
+        this->write(ELE_CFG,0x30); //Sense proximity from ALL pads
+    } else {
+        this->write(ELE_CFG,0x0c); //Sense touch, all 12 pads active.
+    }
+}
+
+
+int Mpr121::readTouchData(){
+    return this->read(0x00);
+}
diff -r 000000000000 -r a1c374b9a4fe mpr121/mpr121.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mpr121/mpr121.h	Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,158 @@
+/*
+Copyright (c) 2011 Anthony Buckton (abuckton [at] blackink [dot} net {dot} au)
+
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+   Parts written by Jim Lindblom of Sparkfun
+   Ported to mbed by A.Buckton, Feb 2011
+*/
+
+#ifndef MPR121_H
+#define MPR121_H
+
+//using namespace std;
+
+class Mpr121 
+{
+
+public:
+    // i2c Addresses, bit-shifted
+    enum Address { ADD_VSS = 0xb4,// ADD->VSS = 0x5a <-wiring on Sparkfun board
+                   ADD_VDD = 0xb6,// ADD->VDD = 0x5b
+                   ADD_SCL = 0xb8,// ADD->SDA = 0x5c
+                   ADD_SDA = 0xba // ADD->SCL = 0x5d
+                 };
+
+    // Real initialiser, takes the i2c address of the device.
+    Mpr121(I2C *i2c, Address i2cAddress);
+    
+    bool getProximityMode();
+    
+    void setProximityMode(bool mode);
+    
+    int readTouchData();
+               
+    unsigned char read(int key);
+    
+    int write(int address, unsigned char value);
+    int writeMany(int start, unsigned char* dataSet, int length);
+
+    void setElectrodeThreshold(int electrodeId, unsigned char touchThreshold, unsigned char releaseThreshold);
+        
+protected:
+    // Configures the MPR with standard settings. This is permitted to be overwritten by sub-classes.
+    void configureSettings();
+    
+private:
+    // The I2C bus instance.
+    I2C *i2c;
+
+    // i2c address of this mpr121
+    Address address;
+};
+
+
+// MPR121 Register Defines
+#define    MHD_R        0x2B
+#define    NHD_R        0x2C
+#define    NCL_R        0x2D
+#define    FDL_R        0x2E
+#define    MHD_F        0x2F
+#define    NHD_F        0x30
+#define    NCL_F        0x31
+#define    FDL_F        0x32
+#define    NHDT         0x33
+#define    NCLT         0x34
+#define    FDLT         0x35
+// Proximity sensing controls
+#define    MHDPROXR     0x36
+#define    NHDPROXR     0x37
+#define    NCLPROXR     0x38
+#define    FDLPROXR     0x39
+#define    MHDPROXF     0x3A
+#define    NHDPROXF     0x3B
+#define    NCLPROXF     0x3C
+#define    FDLPROXF     0x3D
+#define    NHDPROXT     0x3E
+#define    NCLPROXT     0x3F
+#define    FDLPROXT     0x40
+// Electrode Touch/Release thresholds
+#define    ELE0_T       0x41
+#define    ELE0_R       0x42
+#define    ELE1_T       0x43
+#define    ELE1_R       0x44
+#define    ELE2_T       0x45
+#define    ELE2_R       0x46
+#define    ELE3_T       0x47
+#define    ELE3_R       0x48
+#define    ELE4_T       0x49
+#define    ELE4_R       0x4A
+#define    ELE5_T       0x4B
+#define    ELE5_R       0x4C
+#define    ELE6_T       0x4D
+#define    ELE6_R       0x4E
+#define    ELE7_T       0x4F
+#define    ELE7_R       0x50
+#define    ELE8_T       0x51
+#define    ELE8_R       0x52
+#define    ELE9_T       0x53
+#define    ELE9_R       0x54
+#define    ELE10_T      0x55
+#define    ELE10_R      0x56
+#define    ELE11_T      0x57
+#define    ELE11_R      0x58
+// Proximity Touch/Release thresholds
+#define    EPROXTTH     0x59
+#define    EPROXRTH     0x5A
+// Debounce configuration
+#define    DEB_CFG      0x5B
+// AFE- Analogue Front End configuration
+#define    AFE_CFG      0x5C 
+// Filter configuration
+#define    FIL_CFG      0x5D
+// Electrode configuration - transistions to "active mode"
+#define    ELE_CFG      0x5E
+
+#define GPIO_CTRL0      0x73
+#define GPIO_CTRL1      0x74
+#define GPIO_DATA       0x75
+#define    GPIO_DIR     0x76
+#define    GPIO_EN      0x77
+#define    GPIO_SET     0x78
+#define GPIO_CLEAR      0x79
+#define GPIO_TOGGLE     0x7A
+// Auto configration registers
+#define    AUTO_CFG_0   0x7B
+#define    AUTO_CFG_U   0x7D
+#define    AUTO_CFG_L   0x7E
+#define    AUTO_CFG_T   0x7F
+
+// Threshold defaults
+// Electrode touch threshold
+#define    E_THR_T      0x0F   
+// Electrode release threshold 
+#define    E_THR_R      0x0A    
+// Prox touch threshold
+#define    PROX_THR_T   0x02
+// Prox release threshold
+#define    PROX_THR_R   0x02
+
+#endif
+
diff -r 000000000000 -r a1c374b9a4fe wave_player.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/wave_player.lib	Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,1 @@
+http://developer.mbed.org/users/zchen311/code/wave_player/#353c78110e44