Allow user to connect multiple screen.

Dependencies:   mbed-rtos mbed

Files at this revision

API Documentation at this revision

Comitter:
Ratchapong
Date:
Wed Mar 11 05:00:37 2015 +0000
Commit message:
Working

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
Game.h Show annotated file Show diff for this revision Revisions of this file
Graphics.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-rtos.lib 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
uLCD_Multiscreen/BackgroundColor.cpp Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/BackgroundColor.h Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/BaudRate.cpp Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/BaudRate.h Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/Blit.cpp Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/Blit.h Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/ClearScreen.cpp Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/ClearScreen.h Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/Command.h Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/DrawPixel.cpp Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/DrawPixel.h Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/Reset.cpp Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/Reset.h Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/ScreenUpdater.cpp Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/ScreenUpdater.h Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/VirtualScreen.h Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/uLCD_Multiscreen.cpp Show annotated file Show diff for this revision Revisions of this file
uLCD_Multiscreen/uLCD_Multiscreen.h Show annotated file Show diff for this revision Revisions of this file
diff -r 000000000000 -r 052d0f82433e 4DGL-uLCD-SE/uLCD_4DGL.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/4DGL-uLCD-SE/uLCD_4DGL.h	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,344 @@
+#ifndef ULCD_4DGL_H
+#define ULCD_4DGL_H
+//
+// 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"
+
+// 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
+*/
+using namespace mbed;
+
+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 052d0f82433e 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	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,310 @@
+//
+// 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[2] = "";
+
+    freeBUFFER();
+
+    for (i = 0; i < 6; i++) {                   // send all chars to serial port
+        writeBYTE(command[i]);
+    }
+
+    while (!_cmd.readable()) wait_ms(TEMPO);    // wait for screen answer
+
+    while (_cmd.readable() && resp < ARRAY_SIZE(response)) {
+        temp = _cmd.getc();
+        response[resp++] = (char)temp;
+    }
+
+    color = ((response[0] << 8) + response[1]);
+
+    return color; // WARNING : this is 16bits color, not 24bits... need to be fixed
+}
+
+
+//****************************************************************************************************
+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 052d0f82433e 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	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,177 @@
+//
+// 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 052d0f82433e 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	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,343 @@
+//
+// 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 052d0f82433e 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	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,469 @@
+//
+// 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 052d0f82433e Game.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Game.h	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,75 @@
+#include "Graphics.h"
+
+
+
+class Controller
+{
+public:
+
+    AnalogIn& sliderh;
+    AnalogIn& sliderv;
+
+public:
+    Controller(AnalogIn& sliderh, AnalogIn& sliderv) : sliderh(sliderh), sliderv(sliderv) {
+
+    }
+};
+
+class Game
+{
+private:
+    Renderer& renderer;
+    Controller& controller;
+    Scene scene;
+
+public:
+    Game(Renderer& renderer, Controller& ctrl)
+        : renderer(renderer), controller(ctrl) {
+        
+        scene.bg = renderer.background;
+
+        buildScene();
+    }
+
+private:
+    void buildScene() {
+
+
+        Block pad;
+        pad.locked = true;
+        pad.coord.x = 10;
+        pad.coord.y = 10;
+        pad.copy();
+        pad.color = -1;
+        scene.paddle = pad;
+    }
+
+
+public:
+    void getInput(int posx, int posy) {
+        scene.paddle.store_prev();
+
+        if (posx > 600) {
+            scene.paddle.coord.x = scene.paddle.coord.x + 5;
+        } else if (posx < 400) {
+            scene.paddle.coord.x = scene.paddle.coord.x - 5;
+        }
+        
+        if (posy > 600) {
+            scene.paddle.coord.y = scene.paddle.coord.y + 5;
+        } else if (posy < 400) {
+            scene.paddle.coord.y = scene.paddle.coord.y - 5;
+        }
+        
+
+        scene.paddle.updated = true;
+    }
+    
+    
+    void loop() {
+        renderer.render(scene);
+    }
+    
+
+};
+
diff -r 000000000000 -r 052d0f82433e Graphics.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Graphics.h	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,105 @@
+#include "uLCD_Multiscreen.h"
+
+struct vec2 {
+    float x;
+    float y;
+};
+
+
+class Renderer;
+
+
+class Block
+{
+    friend Renderer;
+
+private:
+
+    vec2 next_coord;
+    vec2 next_size;
+
+public:
+    bool updated;
+    bool locked;
+
+    bool render;
+    vec2 coord;
+    vec2 size;
+
+    int color;
+
+    vec2 prev_coord;
+    vec2 prev_size;
+
+    Block() :  updated(true), locked(false), render(true) {
+        coord.x = 0;
+        coord.y = 0;
+        color = RED;
+        size.x = 2;
+        size.y = 2;
+    }
+    
+    virtual void next_swap(){
+      coord = next_coord;
+      size = next_size;
+
+  }
+
+    void store_prev() {
+        prev_coord = coord;
+        prev_size = size;
+    }
+    
+    void copy() {
+        prev_coord = coord;
+        prev_size = size;
+
+        next_coord = coord;
+        next_size = size;
+
+    }
+
+    
+};
+
+
+class Scene
+{
+public:
+    int bg;
+    Block paddle;
+
+};
+
+
+class Renderer
+{
+private:
+public:
+    uLCD_Multiscreen& g;
+    int background;
+    vec2 screen;
+
+    Renderer(uLCD_Multiscreen& gfx, vec2 screen) : g(gfx), screen(screen) {
+    }
+    void render(Scene s) {
+
+
+        //draw paddle
+        {
+            Block* b = &(s.paddle);
+            if(b->updated) {
+                //draw over where it was
+                g.unfilledCirlce(b->prev_coord.x, b->prev_coord.y, 10, background);       //x1,y1,x2,y2,color
+                //draw new location
+                g.unfilledCirlce(b->coord.x, b->coord.y, 10,  b->color);       //x1,y1,x2,y2,color
+
+                b->updated = false;
+            }
+        }
+
+
+
+
+    }
+};
\ No newline at end of file
diff -r 000000000000 -r 052d0f82433e main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,55 @@
+#include "mbed.h"
+#include "rtos.h"
+#include "uLCD_4DGL.h"
+#include "Game.h"
+#include "uLCD_Multiscreen.h"
+
+
+//already defined
+//#define SIZE_X       128
+//#define SIZE_Y       128
+ 
+//display
+uLCD_4DGL screen1(p28, p27, p11);
+uLCD_4DGL screen2(p9, p10, p11);
+std::vector<uLCD_4DGL*> my_screens;
+
+
+//inputs
+AnalogIn sliderh(p15);
+AnalogIn sliderv(p16);
+
+
+
+//game objects
+
+
+
+
+int main() {
+    my_screens.push_back(&screen1);
+    my_screens.push_back(&screen2);
+uLCD_Multiscreen multiscreen(my_screens);
+Controller  controller(sliderh, sliderv);
+vec2        screen = {SIZE_X, SIZE_Y};
+Renderer    gfx(multiscreen, screen);
+Game        game(gfx, controller);
+
+
+
+    multiscreen.setBaudRate(3000000);
+    multiscreen.changeBackground(0x444444);
+    gfx.background = 0x444444;
+    multiscreen.cls();
+    //multiscreen.unfilledRectangle(0, 0, 50, 10, -1);
+    
+    while(true){
+        int x = sliderh.read()* 1000;
+        int y = sliderv.read()* 1000;
+
+        //printf(controller.sliderv );
+        game.loop();
+        game.getInput(x, y);
+        //Thread::wait(10);
+    }
+}
\ No newline at end of file
diff -r 000000000000 -r 052d0f82433e mbed-rtos.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed-rtos.lib	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed-rtos/#63988a2238f7
diff -r 000000000000 -r 052d0f82433e mbed.bld
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed/builds/7e07b6fb45cf
\ No newline at end of file
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/BackgroundColor.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/BackgroundColor.cpp	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,8 @@
+#include "BackgroundColor.h"
+#include "uLCD_4DGL.h"
+BackgroundColor::BackgroundColor(int color) {
+    this->color = color;
+}
+void BackgroundColor::execute(uLCD_4DGL* uLCD) {
+    uLCD->background_color(color);     
+}
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/BackgroundColor.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/BackgroundColor.h	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,12 @@
+#ifndef BACKGROUNDCOLOR_H
+#define BACKGROUNDCOLOR_H
+#include "Command.h"
+#include "uLCD_4DGL.h"
+class BackgroundColor: public Command {
+    private:
+        int color;
+    public:
+        BackgroundColor(int color);
+        virtual void execute(uLCD_4DGL* uLCD);
+};
+#endif
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/BaudRate.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/BaudRate.cpp	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,8 @@
+#include "BaudRate.h"
+#include "uLCD_4DGL.h"
+BaudRate::BaudRate(int rate) {
+    this->rate = rate;
+}
+void BaudRate::execute(uLCD_4DGL* uLCD) {
+    uLCD->baudrate(rate);     
+}
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/BaudRate.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/BaudRate.h	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,12 @@
+#ifndef BAUDRATE_H
+#define BAUDRATE_H
+#include "Command.h"
+#include "uLCD_4DGL.h"
+class BaudRate: public Command {
+    private:
+        int rate;
+    public:
+        BaudRate(int rate);
+        virtual void execute(uLCD_4DGL* uLCD);
+};
+#endif
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/Blit.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/Blit.cpp	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,14 @@
+#include "Blit.h"
+Blit::Blit(int x, int y, int w, int h, int *colors) {
+    this->x = x;
+    this->y = y;
+    this->w = w;
+    this->h = h;
+    this->colors = new int[w*h];
+    for (int i = 0; i < w*h; i++) {
+        this->colors[i] = colors[i];
+    }
+}
+void Blit::execute(uLCD_4DGL* uLCD) {
+    uLCD->BLIT(x,y,w,h,colors);
+}
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/Blit.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/Blit.h	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,16 @@
+#ifndef BLIT_H
+#define BLIT_H
+#include "Command.h"
+#include "uLCD_4DGL.h"
+class Blit: public Command {
+    private:
+        int x;
+        int y;
+        int w;
+        int h;
+        int *colors;
+    public:
+        Blit(int x, int y, int w, int h, int *colors);
+        virtual void execute(uLCD_4DGL* uLCD);
+};
+#endif
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/ClearScreen.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/ClearScreen.cpp	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,5 @@
+#include "ClearScreen.h"
+#include "uLCD_4DGL.h"
+void ClearScreen::execute(uLCD_4DGL* uLCD) {
+    uLCD->cls();     
+}
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/ClearScreen.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/ClearScreen.h	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,8 @@
+#ifndef CLEARSCREEN_H
+#define CLEARSCREEN_H
+#include "Command.h"
+#include "uLCD_4DGL.h"
+class ClearScreen: public Command {
+    virtual void execute(uLCD_4DGL* uLCD);
+};
+#endif
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/Command.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/Command.h	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,15 @@
+#ifndef COMMAND_H
+#define COMMAND_H
+#include "uLCD_4DGL.h"
+/**
+ * Class represents a uLCD command. 
+ */
+class Command {
+        public:
+        /**
+         * Executes the command on the target uLCD.
+         * @param uLCD the lcd to execute the command on.
+         */
+        virtual void execute(uLCD_4DGL* uLCD) = 0;
+};
+#endif
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/DrawPixel.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/DrawPixel.cpp	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,10 @@
+#include "DrawPixel.h"
+#include "uLCD_4DGL.h"
+DrawPixel::DrawPixel(int x, int y, int color) {
+    this->x = x;
+    this->y = y;
+    this->color = color;
+}
+void DrawPixel::execute(uLCD_4DGL* uLCD) {
+    uLCD->pixel(x,y,color);     
+}
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/DrawPixel.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/DrawPixel.h	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,14 @@
+#ifndef DRAWPIXEL_H
+#define DRAWPIXEL_H
+#include "Command.h"
+#include "uLCD_4DGL.h"
+class DrawPixel: public Command {
+    private:
+        int x;
+        int y;
+        int color;
+    public:
+        DrawPixel(int x, int y, int color);
+        virtual void execute(uLCD_4DGL* uLCD);
+};
+#endif
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/Reset.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/Reset.cpp	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,5 @@
+#include "Reset.h"
+#include "uLCD_4DGL.h"
+void Reset::execute(uLCD_4DGL* uLCD) {
+    uLCD->reset();     
+}
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/Reset.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/Reset.h	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,8 @@
+#ifndef RESET_H
+#define RESET_H
+#include "Command.h"
+#include "uLCD_4DGL.h"
+class Reset: public Command {
+    virtual void execute(uLCD_4DGL* uLCD);
+};
+#endif
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/ScreenUpdater.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/ScreenUpdater.cpp	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,42 @@
+#include "ScreenUpdater.h"
+#include "uLCD_4DGL.h"
+#include "mbed.h"
+static void uLCD_thread_func(void const *args) {
+    //printf("Thread alive.");
+    uLCD_4DGL *lcd = ((uLCD_Thread_Args*)args)->uLCD;
+    std::queue<Command*> *commands = ((uLCD_Thread_Args*)args)->commands;
+    Mutex *commands_mutex = ((uLCD_Thread_Args*)args)->commands_mutex;
+    while (true) {
+        if (!commands->empty()) {
+            commands_mutex->lock();
+            Command *command = commands->front();
+            commands->pop();
+            command->execute(lcd);
+            delete command;
+            commands_mutex->unlock();
+        } else {
+            //printf("empty.");
+            Thread::signal_wait(0x1);
+        }
+    }
+}
+ScreenUpdater::ScreenUpdater(uLCD_4DGL *uLCD) {
+    //printf("ScreenUpdater booting.");
+    uLCD_Thread_Args args = {uLCD, &commands, &commands_mutex};
+    Thread *_thread = new Thread(uLCD_thread_func, &(args), osPriorityHigh);
+    uLCD_thread = _thread;
+    //printf("Thread creation complete\n");
+    this->uLCD = uLCD;
+}
+void ScreenUpdater::addCommand(Command* _command) {
+    //printf("I'm here!");
+    commands_mutex.lock();
+    commands.push(_command);    
+    //printf("Adding command %d. State %d\n", commands.size(), uLCD_thread->get_state());
+    commands_mutex.unlock();
+    uLCD_thread->signal_set(0x1);
+}
+ScreenUpdater::~ScreenUpdater() {
+    //printf("KILLING THREAD!!!!!!!!!!!!!!\n");
+    uLCD_thread->terminate();
+}
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/ScreenUpdater.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/ScreenUpdater.h	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,35 @@
+#ifndef SCREENUPDATER_H
+#define SCREENUPDATER_H
+#include <queue>
+#include "rtos.h"
+#include "uLCD_4DGL.h"
+#include "Command.h"
+/**
+ * Attaches a thread to a physical screen and makes it operate on all input instructions.
+ */
+class ScreenUpdater {
+    private:
+        uLCD_4DGL *uLCD;
+        Thread *uLCD_thread;
+        std::queue<Command*> commands;
+        Mutex commands_mutex;
+    public:
+        /**
+         * Attaches an LCD to the updater.
+         */
+        ScreenUpdater(uLCD_4DGL *uLCD);
+        /**
+         * Add a command to the queue.
+         */
+        void addCommand(Command *_command);
+        /**
+         * Destructor. 
+         */
+        ~ScreenUpdater();
+};
+typedef struct uLCD_Thread_Args {
+    uLCD_4DGL* uLCD;
+    std::queue<Command*>* commands;
+    Mutex* commands_mutex;
+} uLCD_Thread_Args;
+#endif
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/VirtualScreen.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/VirtualScreen.h	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,120 @@
+#ifndef VIRTUALSCREEN_H
+#define VIRTUALSCREEN_H
+#include "ScreenUpdater.h"
+#include "Command.h"
+#include "DrawPixel.h"
+#include "ClearScreen.h"
+#include "BackgroundColor.h"
+#include "Reset.h"
+#include "BaudRate.h"
+#include "Blit.h"
+#include "mbed.h"
+/**
+ * Class represents a virtual screen of arbitrary size. To keep simplicity, screen data should be kept
+ * in a pixel format where it can be read by physical devices.
+ */
+template <class pixelType, class screenType>
+class VirtualScreen {
+    private:
+        std::vector<screenType*> screens;
+        std::vector<ScreenUpdater*> updaters; 
+        int rows;
+        int columns;
+        int screenSize;
+    public:
+        /**
+         * Creates a virtual screen of size rows * columns. This screen is partitioned into different physical
+         * screens. Writing pixels into this screen will transparently write into
+         * these separate screens.
+         *
+         * @param screens A vector of physical screens to be used for drawing on.
+         * @param rows The number of rows in the virtual screen.
+         * @param columns The number of columns in the virtual screen. 
+         */
+        VirtualScreen<pixelType, screenType>(std::vector<screenType*> screens, int rows, int columns) {
+            printf("Virtual Screen Booting.");
+            this->screens = screens;
+            for (typename std::vector<screenType*>::iterator scr_iter = screens.begin(); scr_iter != screens.end(); scr_iter++) {
+                ScreenUpdater *updater = new ScreenUpdater(*scr_iter);
+                updaters.push_back(updater);
+            }    
+            this->rows = rows;
+            this->columns = columns;
+            this->screenSize = 128;
+        }
+        
+        ~VirtualScreen<pixelType, screenType>() {
+            for (typename std::vector<ScreenUpdater*>::iterator updater_iter = updaters.begin(); updater_iter != updaters.end(); updater_iter++) {
+                delete (*updater_iter);
+            }
+        }
+        
+        /**
+         * Writes a pixel value into the virtual screen at (row, column) index.
+         *
+         * @param x The row to write the pixel to.
+         * @param y The column to write the pixel to.
+         * @param value The value to write to the pixel.
+         */
+        void setPixel(int x, int y, pixelType value) {
+            //printf("Set pixel on row %d, col %d, val %d\n", x, y, value);
+            int screen_number = x / screenSize; 
+            int x_pixel = x % screenSize; 
+            //printf("Predicting screen %d, at col %d\n", screen_number, x_pixel);
+            ScreenUpdater* updater = updaters.at(screen_number); 
+            //printf("Updater made.\n"); 
+            Command *command = new DrawPixel(x_pixel, y, value); 
+           //printf("Adding command.\n");
+            updater->addCommand(command); 
+        }
+        /**
+         * Clears the screens of all attached screens.
+         */
+        void clearScreen() {
+            for (typename std::vector<ScreenUpdater*>::iterator updater_iter = updaters.begin(); updater_iter != updaters.end(); updater_iter++) {
+                Command* command = new ClearScreen(); 
+                (*updater_iter)->addCommand(command);
+            }
+        }
+        /**
+         * Resets the screens of all attached screens.
+         */
+        void resetScreen() {
+            for (typename std::vector<ScreenUpdater*>::iterator updater_iter = updaters.begin(); updater_iter != updaters.end(); updater_iter++) {
+                Command* command = new Reset(); 
+                (*updater_iter)->addCommand(command);
+            }
+        }
+        /**
+         * Sets the baud rate for all screens.
+         *
+         * @param rate The desired baud rate.
+         */
+        void setBaudRate(int rate) {
+            for (typename std::vector<ScreenUpdater*>::iterator updater_iter = updaters.begin(); updater_iter != updaters.end(); updater_iter++) {
+                Command* command = new BaudRate(rate); 
+                (*updater_iter)->addCommand(command);
+            }
+        }
+        /**
+         * draw a block of pixels
+         */
+        void BLIT(int x, int y, int w, int h, int *colors) {
+            for (typename std::vector<ScreenUpdater*>::iterator updater_iter = updaters.begin(); updater_iter != updaters.end(); updater_iter++) {
+                Command* command = new Blit(x,y,w,h,colors); 
+                (*updater_iter)->addCommand(command);
+            }
+        }
+        /**
+         * Sets the background color for all screens.
+         *
+         * @param color The color of the desired background.
+         */
+        void background_color(int color) {
+            for (typename std::vector<ScreenUpdater*>::iterator updater_iter = updaters.begin(); updater_iter != updaters.end(); updater_iter++) {
+                Command* command = new BackgroundColor(color); 
+                (*updater_iter)->addCommand(command);
+            }
+        }
+};
+#endif
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/uLCD_Multiscreen.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/uLCD_Multiscreen.cpp	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,121 @@
+#include "uLCD_Multiscreen.h"
+#include "mbed.h"
+uLCD_Multiscreen::uLCD_Multiscreen(vector<uLCD_4DGL*> screens) : virtualScreen(screens, 128, 128 * screens.size())
+{
+    printf("Multiscreen Booting.");
+}
+
+void uLCD_Multiscreen::unfilledRectangle(int x, int y, int w, int h, int color)
+{
+    for(int i = x; i <= x + w; i++) {
+        virtualScreen.setPixel(i, y, color);
+    }
+    for(int i = x; i <= x + w; i++) {
+        virtualScreen.setPixel(i, y + h, color);
+    }
+    
+    for(int i = y; i <= y + h; i++) {
+        virtualScreen.setPixel(x, i, color);
+    }
+    for(int i = y; i <= y + h; i++) {
+        virtualScreen.setPixel(x + w, i, color);
+    }
+
+}
+
+void uLCD_Multiscreen::drawLine(int x1, int y1, int  x2, int  y2, int color)
+{
+    int delta_x(x2 - x1);
+    // if x1 == x2, then it does not matter what we set here
+    signed char const ix((delta_x > 0) - (delta_x < 0));
+    delta_x = std::abs(delta_x) << 1;
+ 
+    int delta_y(y2 - y1);
+    // if y1 == y2, then it does not matter what we set here
+    signed char const iy((delta_y > 0) - (delta_y < 0));
+    delta_y = std::abs(delta_y) << 1;
+ 
+    virtualScreen.setPixel(x1, y1, color);
+ 
+    if (delta_x >= delta_y)
+    {
+        // error may go below zero
+        int error(delta_y - (delta_x >> 1));
+ 
+        while (x1 != x2)
+        {
+            if ((error >= 0) && (error || (ix > 0)))
+            {
+                error -= delta_x;
+                y1 += iy;
+            }
+            // else do nothing
+ 
+            error += delta_y;
+            x1 += ix;
+ 
+            virtualScreen.setPixel(x1, y1, color);
+        }
+    }
+    else
+    {
+        // error may go below zero
+        int error(delta_x - (delta_y >> 1));
+ 
+        while (y1 != y2)
+        {
+            if ((error >= 0) && (error || (iy > 0)))
+            {
+                error -= delta_y;
+                x1 += ix;
+            }
+            // else do nothing
+ 
+            error += delta_x;
+            y1 += iy;
+ 
+            virtualScreen.setPixel(x1, y1, color);
+        }
+    }
+}
+
+void uLCD_Multiscreen::unfilledCirlce(int x0, int y0, int radius, int color)
+{
+    int x = radius;
+  int y = 0;
+  int radiusError = 1-x;
+ 
+  while(x >= y)
+  {
+    virtualScreen.setPixel(x + x0, y + y0, color);
+    virtualScreen.setPixel(y + x0, x + y0, color);
+    virtualScreen.setPixel(-x + x0, y + y0, color);
+    virtualScreen.setPixel(-y + x0, x + y0, color);
+    virtualScreen.setPixel(-x + x0, -y + y0, color);
+    virtualScreen.setPixel(-y + x0, -x + y0, color);
+    virtualScreen.setPixel(x + x0, -y + y0, color);
+    virtualScreen.setPixel(y + x0, -x + y0, color);
+    y++;
+    if (radiusError<0)
+    {
+      radiusError += 2 * y + 1;
+    }
+    else
+    {
+      x--;
+      radiusError += 2 * (y - x) + 1;
+    }
+  }
+}
+
+void uLCD_Multiscreen::cls() {
+    virtualScreen.clearScreen();
+}
+
+
+void uLCD_Multiscreen::changeBackground(int color) {
+    virtualScreen.background_color(color);
+}
+void uLCD_Multiscreen::setBaudRate(int rate) {
+    virtualScreen.setBaudRate(rate);
+}
diff -r 000000000000 -r 052d0f82433e uLCD_Multiscreen/uLCD_Multiscreen.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uLCD_Multiscreen/uLCD_Multiscreen.h	Wed Mar 11 05:00:37 2015 +0000
@@ -0,0 +1,22 @@
+#ifndef ULCD_MULTISCREEN_H
+#define ULCD_MULTISCREEN_H
+#include "VirtualScreen.h"
+#include "uLCD_4DGL.h"
+/**
+ * CLass represents an interface for seemlessly writing to multiple uLCD screens
+ * in parallel.
+ */
+class uLCD_Multiscreen {
+    private:
+        VirtualScreen<int, uLCD_4DGL> virtualScreen;
+        int screen_count;
+    public:
+        uLCD_Multiscreen(vector<uLCD_4DGL*> screens);
+        void cls();
+        void unfilledRectangle(int x, int y, int w, int h, int color);
+        void drawLine(int x1,int y1,int  x2, int  y2, int color);
+        void unfilledCirlce(int x0, int y0, int radius, int color);
+        void changeBackground(int color);
+        void setBaudRate(int rate);
+};
+#endif