a white square appears on SPI LCD which controlled by WII nunchuck on the other hand it outputs log mwessage on USBTX/RX incompatible with latest mbed library

Dependencies:   WiiChuck mbed

Files at this revision

API Documentation at this revision

Comitter:
k4zuki
Date:
Tue Aug 27 14:31:22 2013 +0000
Commit message:
p9 and p10 forI2C, p11,12,13,14,23 are for SPI, R/S select and reset

Changed in this revision

GraphicsDisplay.cpp Show annotated file Show diff for this revision Revisions of this file
GraphicsDisplay.h Show annotated file Show diff for this revision Revisions of this file
ST7735_TFT.cpp Show annotated file Show diff for this revision Revisions of this file
ST7735_TFT.h Show annotated file Show diff for this revision Revisions of this file
TextDisplay.cpp Show annotated file Show diff for this revision Revisions of this file
TextDisplay.h Show annotated file Show diff for this revision Revisions of this file
WiiChuck.lib 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
diff -r 000000000000 -r 0c777a879891 GraphicsDisplay.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/GraphicsDisplay.cpp	Tue Aug 27 14:31:22 2013 +0000
@@ -0,0 +1,176 @@
+/* mbed GraphicsDisplay Display Library Base Class
+ * Copyright (c) 2007-2009 sford
+ * Released under the MIT License: http://mbed.org/license/mit
+ */
+ 
+#include "GraphicsDisplay.h"
+
+const unsigned char FONT8x8[97][8] = {
+0x08,0x08,0x08,0x00,0x00,0x00,0x00,0x00, // columns, rows, num_bytes_per_char
+0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // space 0x20
+0x30,0x78,0x78,0x30,0x30,0x00,0x30,0x00, // !
+0x6C,0x6C,0x6C,0x00,0x00,0x00,0x00,0x00, // "
+0x6C,0x6C,0xFE,0x6C,0xFE,0x6C,0x6C,0x00, // #
+0x18,0x3E,0x60,0x3C,0x06,0x7C,0x18,0x00, // $
+0x00,0x63,0x66,0x0C,0x18,0x33,0x63,0x00, // %
+0x1C,0x36,0x1C,0x3B,0x6E,0x66,0x3B,0x00, // &
+0x30,0x30,0x60,0x00,0x00,0x00,0x00,0x00, // '
+0x0C,0x18,0x30,0x30,0x30,0x18,0x0C,0x00, // (
+0x30,0x18,0x0C,0x0C,0x0C,0x18,0x30,0x00, // )
+0x00,0x66,0x3C,0xFF,0x3C,0x66,0x00,0x00, // *
+0x00,0x30,0x30,0xFC,0x30,0x30,0x00,0x00, // +
+0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x30, // ,
+0x00,0x00,0x00,0x7E,0x00,0x00,0x00,0x00, // -
+0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00, // .
+0x03,0x06,0x0C,0x18,0x30,0x60,0x40,0x00, // / (forward slash)
+0x3E,0x63,0x63,0x6B,0x63,0x63,0x3E,0x00, // 0 0x30
+0x18,0x38,0x58,0x18,0x18,0x18,0x7E,0x00, // 1
+0x3C,0x66,0x06,0x1C,0x30,0x66,0x7E,0x00, // 2
+0x3C,0x66,0x06,0x1C,0x06,0x66,0x3C,0x00, // 3
+0x0E,0x1E,0x36,0x66,0x7F,0x06,0x0F,0x00, // 4
+0x7E,0x60,0x7C,0x06,0x06,0x66,0x3C,0x00, // 5
+0x1C,0x30,0x60,0x7C,0x66,0x66,0x3C,0x00, // 6
+0x7E,0x66,0x06,0x0C,0x18,0x18,0x18,0x00, // 7
+0x3C,0x66,0x66,0x3C,0x66,0x66,0x3C,0x00, // 8
+0x3C,0x66,0x66,0x3E,0x06,0x0C,0x38,0x00, // 9
+0x00,0x18,0x18,0x00,0x00,0x18,0x18,0x00, // :
+0x00,0x18,0x18,0x00,0x00,0x18,0x18,0x30, // ;
+0x0C,0x18,0x30,0x60,0x30,0x18,0x0C,0x00, // <
+0x00,0x00,0x7E,0x00,0x00,0x7E,0x00,0x00, // =
+0x30,0x18,0x0C,0x06,0x0C,0x18,0x30,0x00, // >
+0x3C,0x66,0x06,0x0C,0x18,0x00,0x18,0x00, // ?
+0x3E,0x63,0x6F,0x69,0x6F,0x60,0x3E,0x00, // @ 0x40
+0x18,0x3C,0x66,0x66,0x7E,0x66,0x66,0x00, // A
+0x7E,0x33,0x33,0x3E,0x33,0x33,0x7E,0x00, // B
+0x1E,0x33,0x60,0x60,0x60,0x33,0x1E,0x00, // C
+0x7C,0x36,0x33,0x33,0x33,0x36,0x7C,0x00, // D
+0x7F,0x31,0x34,0x3C,0x34,0x31,0x7F,0x00, // E
+0x7F,0x31,0x34,0x3C,0x34,0x30,0x78,0x00, // F
+0x1E,0x33,0x60,0x60,0x67,0x33,0x1F,0x00, // G
+0x66,0x66,0x66,0x7E,0x66,0x66,0x66,0x00, // H
+0x3C,0x18,0x18,0x18,0x18,0x18,0x3C,0x00, // I
+0x0F,0x06,0x06,0x06,0x66,0x66,0x3C,0x00, // J
+0x73,0x33,0x36,0x3C,0x36,0x33,0x73,0x00, // K
+0x78,0x30,0x30,0x30,0x31,0x33,0x7F,0x00, // L
+0x63,0x77,0x7F,0x7F,0x6B,0x63,0x63,0x00, // M
+0x63,0x73,0x7B,0x6F,0x67,0x63,0x63,0x00, // N
+0x3E,0x63,0x63,0x63,0x63,0x63,0x3E,0x00, // O
+0x7E,0x33,0x33,0x3E,0x30,0x30,0x78,0x00, // P 0x50
+0x3C,0x66,0x66,0x66,0x6E,0x3C,0x0E,0x00, // Q
+0x7E,0x33,0x33,0x3E,0x36,0x33,0x73,0x00, // R
+0x3C,0x66,0x30,0x18,0x0C,0x66,0x3C,0x00, // S
+0x7E,0x5A,0x18,0x18,0x18,0x18,0x3C,0x00, // T
+0x66,0x66,0x66,0x66,0x66,0x66,0x7E,0x00, // U
+0x66,0x66,0x66,0x66,0x66,0x3C,0x18,0x00, // V
+0x63,0x63,0x63,0x6B,0x7F,0x77,0x63,0x00, // W
+0x63,0x63,0x36,0x1C,0x1C,0x36,0x63,0x00, // X
+0x66,0x66,0x66,0x3C,0x18,0x18,0x3C,0x00, // Y
+0x7F,0x63,0x46,0x0C,0x19,0x33,0x7F,0x00, // Z
+0x3C,0x30,0x30,0x30,0x30,0x30,0x3C,0x00, // [
+0x60,0x30,0x18,0x0C,0x06,0x03,0x01,0x00, // \ (back slash)
+0x3C,0x0C,0x0C,0x0C,0x0C,0x0C,0x3C,0x00, // ]
+0x08,0x1C,0x36,0x63,0x00,0x00,0x00,0x00, // ^
+0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF, // _
+0x18,0x18,0x0C,0x00,0x00,0x00,0x00,0x00, // ` 0x60
+0x00,0x00,0x3C,0x06,0x3E,0x66,0x3B,0x00, // a
+0x70,0x30,0x3E,0x33,0x33,0x33,0x6E,0x00, // b
+0x00,0x00,0x3C,0x66,0x60,0x66,0x3C,0x00, // c
+0x0E,0x06,0x3E,0x66,0x66,0x66,0x3B,0x00, // d
+0x00,0x00,0x3C,0x66,0x7E,0x60,0x3C,0x00, // e
+0x1C,0x36,0x30,0x78,0x30,0x30,0x78,0x00, // f
+0x00,0x00,0x3B,0x66,0x66,0x3E,0x06,0x7C, // g
+0x70,0x30,0x36,0x3B,0x33,0x33,0x73,0x00, // h
+0x18,0x00,0x38,0x18,0x18,0x18,0x3C,0x00, // i
+0x06,0x00,0x06,0x06,0x06,0x66,0x66,0x3C, // j
+0x70,0x30,0x33,0x36,0x3C,0x36,0x73,0x00, // k
+0x38,0x18,0x18,0x18,0x18,0x18,0x3C,0x00, // l
+0x00,0x00,0x66,0x7F,0x7F,0x6B,0x63,0x00, // m
+0x00,0x00,0x7C,0x66,0x66,0x66,0x66,0x00, // n
+0x00,0x00,0x3C,0x66,0x66,0x66,0x3C,0x00, // o
+0x00,0x00,0x6E,0x33,0x33,0x3E,0x30,0x78, // p
+0x00,0x00,0x3B,0x66,0x66,0x3E,0x06,0x0F, // q
+0x00,0x00,0x6E,0x3B,0x33,0x30,0x78,0x00, // r
+0x00,0x00,0x3E,0x60,0x3C,0x06,0x7C,0x00, // s
+0x08,0x18,0x3E,0x18,0x18,0x1A,0x0C,0x00, // t
+0x00,0x00,0x66,0x66,0x66,0x66,0x3B,0x00, // u
+0x00,0x00,0x66,0x66,0x66,0x3C,0x18,0x00, // v
+0x00,0x00,0x63,0x6B,0x7F,0x7F,0x36,0x00, // w
+0x00,0x00,0x63,0x36,0x1C,0x36,0x63,0x00, // x
+0x00,0x00,0x66,0x66,0x66,0x3E,0x06,0x7C, // y
+0x00,0x00,0x7E,0x4C,0x18,0x32,0x7E,0x00, // z
+0x0E,0x18,0x18,0x70,0x18,0x18,0x0E,0x00, // {
+0x0C,0x0C,0x0C,0x00,0x0C,0x0C,0x0C,0x00, // |
+0x70,0x18,0x18,0x0E,0x18,0x18,0x70,0x00, // }
+0x3B,0x6E,0x00,0x00,0x00,0x00,0x00,0x00, // ~
+0x1C,0x36,0x36,0x1C,0x00,0x00,0x00,0x00}; // DEL
+    
+GraphicsDisplay::GraphicsDisplay(const char *name):TextDisplay(name) {
+    foreground(0xFFFF);
+    background(0x0000);
+}
+    
+void GraphicsDisplay::character(int column, int row, int value) { 
+    blitbit(column * 8, row * 8, 8, 8, (char*)&(FONT8x8[value - 0x1F][0]));
+}
+
+void GraphicsDisplay::window(int x, int y, int w, int h) {
+    // current pixel location
+    _x = x;
+    _y = y;
+    // window settings
+    _x1 = x;
+    _x2 = x + w - 1;
+    _y1 = y;
+    _y2 = y + h - 1;
+}
+    
+void GraphicsDisplay::putp(int colour) {
+    // put pixel at current pixel location
+    pixel(_x, _y, colour);
+    // update pixel location based on window settings
+    _x++;
+    if(_x > _x2) {
+        _x = _x1;
+        _y++;
+        if(_y > _y2) {
+            _y = _y1;
+        }
+    }
+}
+
+void GraphicsDisplay::fill(int x, int y, int w, int h, int colour) { 
+    window(x, y, w, h);
+    for(int i=0; i<w*h; i++) {
+        putp(colour);
+    }
+}
+    
+void GraphicsDisplay::cls() {
+    fill(0, 0, width(), height(), _background);
+}
+    
+void GraphicsDisplay::blit(int x, int y, int w, int h, const int *colour) { 
+    window(x, y, w, h);
+    for(int i=0; i<w*h; i++) {
+        putp(colour[i]);
+    }
+}
+    
+void GraphicsDisplay::blitbit(int x, int y, int w, int h, const char* colour) {
+    window(x, y, w, h);
+    for(int i = 0; i < w*h; i++) {
+        char byte = colour[i >> 3];
+        int offset = i & 0x7;
+        int c = ((byte << offset) & 0x80) ? _foreground : _background;
+        putp(c);
+    }
+}
+    
+int GraphicsDisplay::columns() { 
+    return width() / 8; 
+}
+
+int GraphicsDisplay::rows() { 
+    return height() / 8; 
+}
+
diff -r 000000000000 -r 0c777a879891 GraphicsDisplay.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/GraphicsDisplay.h	Tue Aug 27 14:31:22 2013 +0000
@@ -0,0 +1,55 @@
+/* mbed GraphicsDisplay Display Library Base Class
+ * Copyright (c) 2007-2009 sford
+ * Released under the MIT License: http://mbed.org/license/mit
+ *
+ * A library for providing a common base class for Graphics displays
+ * To port a new display, derive from this class and implement
+ * the constructor (setup the display), pixel (put a pixel
+ * at a location), width and height functions. Everything else
+ * (locate, printf, putc, cls, window, putp, fill, blit, blitbit) 
+ * will come for free. You can also provide a specialised implementation
+ * of window and putp to speed up the results
+ */
+
+#ifndef MBED_GRAPHICSDISPLAY_H
+#define MBED_GRAPHICSDISPLAY_H
+
+#include "TextDisplay.h"
+
+class GraphicsDisplay : public TextDisplay {
+
+public:         
+          
+    GraphicsDisplay(const char* name);
+     
+    virtual void pixel(int x, int y, int colour) = 0;
+    virtual int width() = 0;
+    virtual int height() = 0;
+        
+    virtual void window(int x, int y, int w, int h);
+    virtual void putp(int colour);
+    
+    virtual void cls();
+    virtual void fill(int x, int y, int w, int h, int colour);
+    virtual void blit(int x, int y, int w, int h, const int *colour);    
+    virtual void blitbit(int x, int y, int w, int h, const char* colour);
+    
+    virtual void character(int column, int row, int value);
+    virtual int columns();
+    virtual int rows();
+    
+protected:
+
+    // pixel location
+    short _x;
+    short _y;
+    
+    // window location
+    short _x1;
+    short _x2;
+    short _y1;
+    short _y2;
+
+};
+
+#endif
diff -r 000000000000 -r 0c777a879891 ST7735_TFT.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ST7735_TFT.cpp	Tue Aug 27 14:31:22 2013 +0000
@@ -0,0 +1,814 @@
+ /* mbed library for 128*160 pixel display TFT based on ST7735 LCD Controller
+ * ST7735 specific routines (initialization, window addressing, pixel output) 
+ * Copyright (c) 2011 Jonne Valola
+ *
+ * WARNING !! WORK IN PROGRESS !!!
+ *
+ * Graphics routines and SPI routines derived work used with permission from:
+ * mbed library for 240*320 pixel display TFT based on HX8347D LCD Controller
+ * Copyright (c) 2011 Peter Drescher - DC2PD
+ *
+ * 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 "ST7735_TFT.h"
+#include "mbed.h"
+
+#define BPP         16                  // Bits per pixel                
+
+ST7735_TFT::ST7735_TFT(PinName mosi, PinName miso, PinName sclk, PinName cs, PinName rs, PinName reset, const char *name)
+        : _spi(mosi, miso, sclk), _cs(cs), _rs(rs), _reset(reset),GraphicsDisplay(name) {
+    tft_reset();
+    orientation = 2;
+    char_x = 0;
+}
+
+
+int ST7735_TFT::width() {
+    if (orientation == 0 || orientation == 2) return 130;
+    else return 162; 
+}
+
+
+int ST7735_TFT::height() {
+    if (orientation == 0 || orientation == 2) return 162;
+    else return 130; 
+}
+
+
+void ST7735_TFT::set_orientation(unsigned int o) {
+    orientation = o;
+    switch (orientation) {
+        case 0:
+            wr_reg(ST7735_MADCTL, 0x0008);
+            break;
+        case 1:
+            wr_reg(ST7735_MADCTL, 0x0068);
+            break;
+        case 2:
+            wr_reg(ST7735_MADCTL, 0x00C8);
+            break;
+        case 3:
+            wr_reg(ST7735_MADCTL, 0x00A8);
+            break;
+    }
+}
+
+
+
+void ST7735_TFT::wr_cmd(int cmd) {
+    _rs = 0; // rs low, cs low for transmitting command
+    _cs = 0;
+    _spi.write(cmd);
+    _cs = 1;
+}
+
+
+
+void ST7735_TFT::wr_dat(int dat) {
+    _rs = 1; // rs high, cs low for transmitting data
+    _cs = 0;                         
+    _spi.write(dat);                                                           
+    _cs = 1;
+}
+
+
+
+void ST7735_TFT::wr_dat_start(void) {
+    _rs = 1; //  rs high, cs low for transmitting data
+    _cs = 0;
+}
+
+
+
+void ST7735_TFT::wr_dat_stop (void) {
+    _cs = 1;
+}
+
+
+
+void ST7735_TFT::wr_dat_only (unsigned short dat) {  
+    _spi.write(dat);                                            
+}
+
+
+unsigned short ST7735_TFT::rd_dat (void) {
+    unsigned short val = 0;
+    _cs = 0;
+    _spi.write(0);                                /* Dummy read 1                 */
+    val   = _spi.write(0);                        /* Read D8..D15                 */
+    val <<= 8;
+    val  |= _spi.write(0);                        /* Read D0..D7                  */
+    _cs = 1;
+    return (val);
+}
+
+void ST7735_TFT::wr_reg (unsigned char reg, unsigned short val) {
+
+    wr_cmd(reg);
+    wr_dat(val);
+}
+
+
+unsigned short ST7735_TFT::rd_reg (unsigned char reg) {
+
+    wr_cmd(reg);
+    return(rd_dat());
+}
+
+void ST7735_TFT::read_area(unsigned int x, unsigned int y, unsigned int w, unsigned int h,unsigned char *buffer) {
+    // BEWARE !
+    // DOES NOT WORK CORRECTLY YET !!!
+    int val;
+    window(x,y,w,h);
+    wr_cmd(ST7735_RAMRD);  // write to RAM
+    _cs = 0;
+    _rs = 1;
+    _spi.write(0);                                /* Dummy read 1                 */
+    
+    val   = _spi.write(0);                        /* Read D8..D15                 */
+    val <<= 8;
+    val  |= _spi.write(0);                        /* Read D0..D7                  */
+    _cs = 1;
+}
+
+int ST7735_TFT::getpixel(unsigned int x, unsigned int y) {
+    // BEWARE !
+    // DOES NOT WORK CORRECTLY YET !!!
+    int val;
+    _spi.format(8,3);
+    wr_cmd(ST7735_CASET);  // column addr set
+    wr_dat(0x00);
+    wr_dat(x+2);   // XSTART 
+    wr_dat(0x00);
+    wr_dat(x+2+2);   // XEND
+
+    wr_cmd(ST7735_RASET);  // row addr set
+    wr_dat(0x00);
+    wr_dat(y+1);    // YSTART
+    wr_dat(0x00);
+    wr_dat(y+1+1);    // YEND
+    
+    _rs = 0; // rs low, cs low for transmitting command
+    _cs = 0;
+    _spi.write(0x2E);
+    _rs = 1;
+    _spi.write(0x00);                                /* Dummy read 1                 */
+    
+    val   = _spi.write(0x00);                        /* Read D8..D15                 */
+    val <<= 8;
+    val  |= _spi.write(0x00);                        /* Read D0..D7                  */
+
+    _cs = 1;
+    return val;
+}
+
+
+void ST7735_TFT::tft_reset() {
+    static unsigned short driverCode;
+    
+    // init SPI
+    _spi.format(8,3);                 // 8 bit spi mode 3
+    _spi.frequency(16000000);         // 16Mhz SPI clock ... 15Mhz is maximum for display, but it seems to work
+    
+    // reset exactly like in Arduino version
+    _cs = 0;
+    _reset = 1;                       // reset
+    wait_ms(500);
+    _reset = 0;                       // reset
+    wait_ms(500);
+    _reset = 1;                       // reset
+    wait_ms(500);
+    
+    /* Start Initial Sequence ----------------------------------------------------*/
+    wr_cmd(ST7735_SWRESET);                         /* SW Reset                       */
+    wait_ms(150);
+    wr_cmd(ST7735_SLPOUT);                         /* Out of sleepmode               */
+    wait_ms(500);
+    
+    wr_cmd(ST7735_FRMCTR1);                         /* Frame rate in normal mode            */
+    wr_dat(0x01);                              
+    wr_dat(0x2C);
+    wr_dat(0x2D);
+    
+    wr_cmd(ST7735_FRMCTR2);                         /* Frame rate in idle mode            */
+    wr_dat(0x01);                              
+    wr_dat(0x2C);
+    wr_dat(0x2D);
+
+    wr_cmd(ST7735_FRMCTR3);                         /* Frame rate in partial mode            */
+    wr_dat(0x01);                              
+    wr_dat(0x2C);
+    wr_dat(0x2D);
+    wr_dat(0x01);   // inversion mode settings                              
+    wr_dat(0x2C);
+    wr_dat(0x2D);
+    
+    wr_cmd(ST7735_INVCTR);   // Inverted mode off
+    wr_dat(0x07);   
+
+    wr_cmd(ST7735_PWCTR1);   // POWER CONTROL 1   
+    wr_dat(0xA2); 
+    wr_dat(0x02);           // -4.6V
+    wr_dat(0x84);           // AUTO mode 
+    
+    wr_cmd(ST7735_PWCTR2);   // POWER CONTROL 2   
+    wr_dat(0xC5);            // VGH25 = 2.4C VGSEL =-10 VGH = 3*AVDD
+    
+    wr_cmd(ST7735_PWCTR3);  // POWER CONTROL 3   
+    wr_dat(0x0A);           // Opamp current small
+    wr_dat(0x00);           // Boost freq
+
+    wr_cmd(ST7735_PWCTR4);   // POWER CONTROL 4   
+    wr_dat(0x8A);            // BCLK/2, Opamp current small / medium low 
+    wr_dat(0x2A);            // 
+  
+    wr_cmd(ST7735_PWCTR5);   // POWER CONTROL 5   
+    wr_dat(0x8A);            // BCLK/2, Opamp current small / medium low 
+    wr_dat(0xEE);            //
+    
+    wr_cmd(ST7735_VMCTR1);   // POWER CONTROL 6   
+    wr_dat(0x0E);            // 
+
+    wr_cmd(ST7735_INVOFF);   // INVOFF
+    
+    wr_cmd(ST7735_MADCTL);   // ORIENTATION   
+    wr_dat(0xC8);   // 
+    
+    wr_cmd(ST7735_COLMOD);   // COLOR MODE   
+    wr_dat(0x05);            //      
+    
+    wr_cmd(ST7735_CASET);   // COLUMN ADDR SET   
+    wr_dat(0x00);   //
+    wr_dat(0x00);   // xstart = 0
+    wr_dat(0x00);   //
+    wr_dat(0x7F);   // xend = 127
+    
+    wr_cmd(ST7735_RASET);   // ROW ADDR SET   
+    wr_dat(0x00);   //
+    wr_dat(0x00);   // ystart = 0
+    wr_dat(0x00);   //
+    wr_dat(0x9F);   // yend = 159            
+    
+    /* Gamma settings  -----------------------------------------------------------*/
+
+  wr_cmd(0xE0); // GMCTRP1
+  wr_dat(0x02);
+  wr_dat(0x1c);
+  wr_dat(0x07);
+  wr_dat(0x12);
+  wr_dat(0x37);
+  wr_dat(0x32);
+  wr_dat(0x29);
+  wr_dat(0x2d);
+  wr_dat(0x29);
+  wr_dat(0x25);
+  wr_dat(0x2B);
+  wr_dat(0x39);
+  wr_dat(0x00);
+  wr_dat(0x01);
+  wr_dat(0x03);
+  wr_dat(0x10);
+  wr_cmd(0xE1); // GMCTRN1
+  wr_dat(0x03); 
+  wr_dat(0x1d); 
+  wr_dat(0x07); 
+  wr_dat(0x06); 
+  wr_dat(0x2E); 
+  wr_dat(0x2C); 
+  wr_dat(0x29); 
+  wr_dat(0x2D); 
+  wr_dat(0x2E); 
+  wr_dat(0x2E); 
+  wr_dat(0x37); 
+  wr_dat(0x3F); 
+  wr_dat(0x00); 
+  wr_dat(0x00); 
+  wr_dat(0x02); 
+  wr_dat(0x10); 
+  
+  wr_cmd(ST7735_DISPON); // display ON
+  wait_ms(100);
+
+  wr_cmd(ST7735_NORON);  // normal display on
+  wait_ms(10);
+  
+  switch (orientation) {
+        case 0:
+            wr_reg(0xC8, 0x0008);
+            break;
+        case 1:
+            wr_reg(0xC8, 0x0068);
+            break;
+        case 2:
+            wr_reg(0xC8, 0x00C8);
+            break;
+        case 3:
+            wr_reg(0xC8, 0x00A8);
+            break;
+    }
+    WindowMax ();
+}
+
+
+void ST7735_TFT::pixel(int x, int y, int color) {
+  if ((x >= width()) || (y >= height())) return;
+
+  window(x,y,x+2,y+2);
+  
+  // setup for data
+   _rs = 1; 
+   _cs = 0;
+  _spi.format(16,3);
+  _spi.write(color);     
+  _cs = 1;
+  _spi.format(8,3);
+}
+
+void ST7735_TFT::window (unsigned int x, unsigned int y, unsigned int w, unsigned int h) {
+  wr_cmd(ST7735_CASET);  // column addr set
+  wr_dat(0x00);
+  wr_dat(x);   // XSTART 
+  wr_dat(0x00);
+  wr_dat(x+w-1);   // XEND
+
+  wr_cmd(ST7735_RASET);  // row addr set
+  wr_dat(0x00);
+  wr_dat(y);    // YSTART
+  wr_dat(0x00);
+  wr_dat(y+h-1);    // YEND
+
+  wr_cmd(ST7735_RAMWR);  // write to RAM
+}
+
+
+void ST7735_TFT::WindowMax (void) {
+    window (0, 0, width(),  height());
+}
+
+
+void ST7735_TFT::cls (void) {
+    unsigned int i;
+    WindowMax();
+    wr_dat_start();
+    _spi.format(16,3);
+    for (i = 0; i < ( (width()+2) * (height()+4)); i++) {
+        _spi.write(_background);    
+    }
+    _spi.format(8,3);
+    wr_dat_stop();
+}
+
+
+void ST7735_TFT::circle(int x0, int y0, int r, int color) {
+
+    int draw_x0, draw_y0;
+    int draw_x1, draw_y1;
+    int draw_x2, draw_y2;
+    int draw_x3, draw_y3;
+    int draw_x4, draw_y4;
+    int draw_x5, draw_y5;
+    int draw_x6, draw_y6;
+    int draw_x7, draw_y7;
+    int xx, yy;
+    int di;
+    WindowMax();
+    if (r == 0) {       /* no radius */
+        return;
+    }
+
+    draw_x0 = draw_x1 = x0;
+    draw_y0 = draw_y1 = y0 + r;
+    if (draw_y0 < height()) {
+        pixel(draw_x0, draw_y0, color);     /* 90 degree */
+    }
+
+    draw_x2 = draw_x3 = x0;
+    draw_y2 = draw_y3 = y0 - r;
+    if (draw_y2 >= 0) {
+        pixel(draw_x2, draw_y2, color);    /* 270 degree */
+    }
+
+    draw_x4 = draw_x6 = x0 + r;
+    draw_y4 = draw_y6 = y0;
+    if (draw_x4 < width()) {
+        pixel(draw_x4, draw_y4, color);     /* 0 degree */
+    }
+
+    draw_x5 = draw_x7 = x0 - r;
+    draw_y5 = draw_y7 = y0;
+    if (draw_x5>=0) {
+        pixel(draw_x5, draw_y5, color);     /* 180 degree */
+    }
+
+    if (r == 1) {
+        return;
+    }
+
+    di = 3 - 2*r;
+    xx = 0;
+    yy = r;
+    while (xx < yy) {
+
+        if (di < 0) {
+            di += 4*xx + 6;
+        } else {
+            di += 4*(xx - yy) + 10;
+            yy--;
+            draw_y0--;
+            draw_y1--;
+            draw_y2++;
+            draw_y3++;
+            draw_x4--;
+            draw_x5++;
+            draw_x6--;
+            draw_x7++;
+        }
+        xx++;
+        draw_x0++;
+        draw_x1--;
+        draw_x2++;
+        draw_x3--;
+        draw_y4++;
+        draw_y5++;
+        draw_y6--;
+        draw_y7--;
+
+        if ( (draw_x0 <= width()) && (draw_y0>=0) ) {
+            pixel(draw_x0, draw_y0, color);
+        }
+
+        if ( (draw_x1 >= 0) && (draw_y1 >= 0) ) {
+            pixel(draw_x1, draw_y1, color);
+        }
+
+        if ( (draw_x2 <= width()) && (draw_y2 <= height()) ) {
+            pixel(draw_x2, draw_y2, color);
+        }
+
+        if ( (draw_x3 >=0 ) && (draw_y3 <= height()) ) {
+            pixel(draw_x3, draw_y3, color);
+        }
+
+        if ( (draw_x4 <= width()) && (draw_y4 >= 0) ) {
+            pixel(draw_x4, draw_y4, color);
+        }
+
+        if ( (draw_x5 >= 0) && (draw_y5 >= 0) ) {
+            pixel(draw_x5, draw_y5, color);
+        }
+        if ( (draw_x6 <=width()) && (draw_y6 <= height()) ) {
+            pixel(draw_x6, draw_y6, color);
+        }
+        if ( (draw_x7 >= 0) && (draw_y7 <= height()) ) {
+            pixel(draw_x7, draw_y7, color);
+        }
+    }
+    return;
+}
+
+void ST7735_TFT::fillcircle(int x, int y, int r, int color) {
+    int i;
+    for (i = 0; i <= r; i++)
+        circle(x,y,i,color);
+}
+
+
+
+void ST7735_TFT::hline(int x0, int x1, int y, int color) {
+    int w;
+    w = x1 - x0 + 1;
+    window(x0,y,w,1);
+    wr_cmd(0x2C);
+    wr_dat_start();
+    for (int x=0; x<w; x++) {
+        _spi.write(color);
+        _spi.write(color >> 8);
+    }
+    wr_dat_stop();
+    return;
+}
+
+
+
+void ST7735_TFT::vline(int x, int y0, int y1, int color) {
+    int h;
+    h = y1 - y0 + 1;
+    window(x,y0,1,h);
+    wr_cmd(0x2C);
+    wr_dat_start();
+    for (int y=0; y<h; y++) {
+        _spi.write(color);
+        _spi.write(color >> 8);
+    }
+    wr_dat_stop();
+    return;
+}
+
+
+
+void ST7735_TFT::line(int x0, int y0, int x1, int y1, int color) {
+    WindowMax();
+    int   dx = 0, dy = 0;
+    int   dx_sym = 0, dy_sym = 0;
+    int   dx_x2 = 0, dy_x2 = 0;
+    int   di = 0;
+
+    dx = x1-x0;
+    dy = y1-y0;
+
+    if (dx == 0) {        /* vertical line */
+        if (y1 > y0) vline(x0,y0,y1,color);
+        else vline(x0,y1,y0,color);
+        return;
+    }
+
+    if (dx > 0) {
+        dx_sym = 1;
+    } else {
+        dx_sym = -1;
+    }
+    if (dy == 0) {        /* horizontal line */
+        if (x1 > x0) hline(x0,x1,y0,color);
+        else  hline(x1,x0,y0,color);
+        return;
+    }
+
+    if (dy > 0) {
+        dy_sym = 1;
+    } else {
+        dy_sym = -1;
+    }
+
+    dx = dx_sym*dx;
+    dy = dy_sym*dy;
+
+    dx_x2 = dx*2;
+    dy_x2 = dy*2;
+
+    if (dx >= dy) {
+        di = dy_x2 - dx;
+        while (x0 != x1) {
+
+            pixel(x0, y0, color);
+            x0 += dx_sym;
+            if (di<0) {
+                di += dy_x2;
+            } else {
+                di += dy_x2 - dx_x2;
+                y0 += dy_sym;
+            }
+        }
+        pixel(x0, y0, color);
+    } else {
+        di = dx_x2 - dy;
+        while (y0 != y1) {
+            pixel(x0, y0, color);
+            y0 += dy_sym;
+            if (di < 0) {
+                di += dx_x2;
+            } else {
+                di += dx_x2 - dy_x2;
+                x0 += dx_sym;
+            }
+        }
+        pixel(x0, y0, color);
+    }
+    return;
+}
+
+
+
+
+void ST7735_TFT::rect(int x0, int y0, int x1, int y1, int color) {
+
+    if (x1 > x0) hline(x0,x1,y0,color);
+    else  hline(x1,x0,y0,color);
+
+    if (y1 > y0) vline(x0,y0,y1,color);
+    else vline(x0,y1,y0,color);
+
+    if (x1 > x0) hline(x0,x1,y1,color);
+    else  hline(x1,x0,y1,color);
+
+    if (y1 > y0) vline(x1,y0,y1,color);
+    else vline(x1,y1,y0,color);
+
+    return;
+}
+
+
+
+void ST7735_TFT::fillrect(int x0, int y0, int x1, int y1, int color) {
+
+    int h = y1 - y0 + 1;
+    int w = x1 - x0 + 1;
+    int pixel = h * w;
+    window(x0,y0,w,h);
+    wr_cmd(0x2C);
+    wr_dat_start();
+    for (int p=0; p<pixel; p++) {
+        _spi.write(color);
+        _spi.write(color >> 8);
+    }
+    wr_dat_stop();
+    return;
+}
+
+
+
+void ST7735_TFT::locate(int x, int y) {
+    char_x = x;
+    char_y = y;
+}
+
+
+
+int ST7735_TFT::columns() {
+    return width() / font[1];
+}
+
+
+
+int ST7735_TFT::rows() {
+    return height() / font[2];
+}
+
+
+
+int ST7735_TFT::_putc(int value) {
+    if (value == '\n') {    // new line
+        char_x = 0;
+        char_y = char_y + font[2];
+        if (char_y >= height() - font[2]) {
+            char_y = 0;
+        }
+    } else {
+        character(char_x, char_y, value);
+     }
+    return value;
+}
+
+
+
+
+void ST7735_TFT::character(int x, int y, int c) {
+    unsigned int hor,vert,offset,bpl,j,i,b;
+    unsigned char* zeichen;
+    unsigned char z,w;
+
+    if ((c < 31) || (c > 127)) return;   // test char range
+
+    // read font parameter from start of array
+    offset = font[0];                    // bytes / char
+    hor = font[1];                       // get hor size of font
+    vert = font[2];                      // get vert size of font
+    bpl = font[3];                       // bytes per line
+
+    if (char_x + hor > width()) {
+        char_x = 0;
+        char_y = char_y + vert;
+       if (char_y >= height() - font[2]) {
+            char_y = 0;
+        }
+    }
+
+    window(char_x, char_y,hor,vert); // char box
+    wr_cmd(0x2C);
+    wr_dat_start();
+    zeichen = &font[((c -32) * offset) + 4]; // start of char bitmap
+    w = zeichen[0];                          // width of actual char
+    _spi.format(16,3);                       // pixel are 16 bit
+
+    for (j=0; j<vert; j++) {  //  vert line
+        for (i=0; i<hor; i++) {   //  horz line
+            z =  zeichen[bpl * i + ((j & 0xF8) >> 3)+1];
+            b = 1 << (j & 0x07);
+            if (( z & b ) == 0x00) {
+                _spi.write(_background);
+            } else {
+                _spi.write(_foreground);
+            }
+        }
+    }
+    _spi.format(8,3);                      // 8 bit
+    wr_dat_stop();
+    if ((w + 2) < hor) {                   // x offset to next char
+        char_x += w + 2;
+    } else char_x += hor;
+}
+
+
+
+
+
+void ST7735_TFT::set_font(unsigned char* f) {
+    font = f;
+}
+
+
+
+void ST7735_TFT::Bitmap(unsigned int x, unsigned int y, unsigned int w, unsigned int h,unsigned char *bitmap) {
+    unsigned int    i,j,value;
+    unsigned short *bitmap_ptr = (unsigned short *)bitmap;
+    window(x, y, w, h);
+    wr_cmd(0x2C);
+    wr_dat_start();
+    for (j = 0; j < h; j++) {        //Lines
+        for (i = 0; i < w; i++) {     // copy pixel data to TFT
+            _spi.write(*bitmap_ptr);    // one line
+            _spi.write(*bitmap_ptr >> 8);  
+            bitmap_ptr++;
+        }
+    }
+    wr_dat_stop();
+}
+
+
+int ST7735_TFT::BMP_16(unsigned int x, unsigned int y, const char *Name_BMP) {
+// BEWARE !
+// NOT TESTED
+#define OffsetPixelWidth    18
+#define OffsetPixelHeigh    22
+#define OffsetFileSize      34
+#define OffsetPixData       10
+#define OffsetBPP           28
+
+    char filename[50];
+    unsigned char BMP_Header[54];
+    unsigned short BPP_t;
+    unsigned int PixelWidth,PixelHeigh,start_data;
+    unsigned int    i,off;
+    int padd,j;
+    unsigned short *line;
+
+    // get the filename
+    LocalFileSystem local("local");
+    sprintf(&filename[0],"/local/");
+    i=7;
+    while (*Name_BMP!='\0') {
+        filename[i++]=*Name_BMP++;
+    }
+    FILE *Image = fopen((const char *)&filename[0], "r");  // open the bmp file
+    if (!Image) {
+        return(0);      // error file not found !
+    }
+
+    fread(&BMP_Header[0],1,54,Image);      // get the BMP Header
+
+    if (BMP_Header[0] != 0x42 || BMP_Header[1] != 0x4D) {  // check magic byte
+        fclose(Image);
+        return(-1);     // error no BMP file
+    }
+
+    BPP_t = BMP_Header[OffsetBPP] + (BMP_Header[OffsetBPP + 1] << 8);
+    if (BPP_t != 0x0010) {
+        fclose(Image);
+        return(-2);     // error no 16 bit BMP
+    }
+
+    PixelHeigh = BMP_Header[OffsetPixelHeigh] + (BMP_Header[OffsetPixelHeigh + 1] << 8) + (BMP_Header[OffsetPixelHeigh + 2] << 16) + (BMP_Header[OffsetPixelHeigh + 3] << 24);
+    PixelWidth = BMP_Header[OffsetPixelWidth] + (BMP_Header[OffsetPixelWidth + 1] << 8) + (BMP_Header[OffsetPixelWidth + 2] << 16) + (BMP_Header[OffsetPixelWidth + 3] << 24);
+    if (PixelHeigh > height() + y || PixelWidth > width() + x) {
+        fclose(Image);
+        return(-3);      // to big
+    }
+
+    start_data = BMP_Header[OffsetPixData] + (BMP_Header[OffsetPixData + 1] << 8) + (BMP_Header[OffsetPixData + 2] << 16) + (BMP_Header[OffsetPixData + 3] << 24);
+
+    line = (unsigned short *) malloc (PixelWidth); // we need a buffer for a line
+    if (line == NULL) {
+        return(-4);         // error no memory
+    }
+
+    // the lines are padded to multiple of 4 bytes
+    padd = -1;
+    do {
+        padd ++;
+    } while ((PixelWidth * 2 + padd)%4 != 0);
+
+    window(x, y,PixelWidth,PixelHeigh);
+    wr_cmd(0x2C);
+    wr_dat_start();
+    _spi.format(16,3);    
+    for (j = PixelHeigh - 1; j >= 0; j--) {               //Lines bottom up
+        off = j * (PixelWidth * 2 + padd) + start_data;   // start of line
+        fseek(Image, off ,SEEK_SET);
+        fread(line,1,PixelWidth * 2,Image);       // read a line - slow !
+        for (i = 0; i < PixelWidth; i++) {        // copy pixel data to TFT
+            _spi.write(line[i]);                  // one 16 bit pixel
+        } 
+    }
+    _spi.format(8,3);
+    wr_dat_stop();
+    free (line);
+    fclose(Image);
+    return(1);
+}
\ No newline at end of file
diff -r 000000000000 -r 0c777a879891 ST7735_TFT.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ST7735_TFT.h	Tue Aug 27 14:31:22 2013 +0000
@@ -0,0 +1,411 @@
+/* mbed library for 128*160 pixel display TFT based on ST7735 LCD Controller
+ * ST7735 specific routines (initialization, window addressing, pixel output) 
+ * Copyright (c) 2011 Jonne Valola
+ *
+ * WARNING !! WORK IN PROGRESS !!!
+ *
+ * Graphics routines and SPI routines derived work used with permission from:
+ * mbed library for 240*320 pixel display TFT based on HX8347D LCD Controller
+ * Copyright (c) 2011 Peter Drescher - DC2PD
+ *
+ * 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.
+ */
+ 
+#ifndef MBED_ST7735_TFT_H
+#define MBED_ST7735_TFT_H
+
+#include "mbed.h"
+#include "GraphicsDisplay.h"
+
+#define RGB(r,g,b)  (((r&0xF8)<<8)|((g&0xFC)<<3)|((b&0xF8)>>3)) //5 red | 6 green | 5 blue
+
+/*define ST7735 Commands */
+
+#define ST7735_NOP 0x0
+#define ST7735_SWRESET 0x01
+#define ST7735_RDDID 0x04
+#define ST7735_RDDST 0x09
+
+#define ST7735_SLPIN  0x10
+#define ST7735_SLPOUT  0x11
+#define ST7735_PTLON  0x12
+#define ST7735_NORON  0x13
+
+#define ST7735_INVOFF 0x20
+#define ST7735_INVON 0x21
+#define ST7735_DISPOFF 0x28
+#define ST7735_DISPON 0x29
+#define ST7735_CASET 0x2A
+#define ST7735_RASET 0x2B
+#define ST7735_RAMWR 0x2C
+#define ST7735_RAMRD 0x2E
+
+#define ST7735_COLMOD 0x3A
+#define ST7735_MADCTL 0x36
+
+
+#define ST7735_FRMCTR1 0xB1
+#define ST7735_FRMCTR2 0xB2
+#define ST7735_FRMCTR3 0xB3
+#define ST7735_INVCTR 0xB4
+#define ST7735_DISSET5 0xB6
+
+#define ST7735_PWCTR1 0xC0
+#define ST7735_PWCTR2 0xC1
+#define ST7735_PWCTR3 0xC2
+#define ST7735_PWCTR4 0xC3
+#define ST7735_PWCTR5 0xC4
+#define ST7735_VMCTR1 0xC5
+
+#define ST7735_RDID1 0xDA
+#define ST7735_RDID2 0xDB
+#define ST7735_RDID3 0xDC
+#define ST7735_RDID4 0xDD
+
+#define ST7735_PWCTR6 0xFC
+
+#define ST7735_GMCTRP1 0xE0
+#define ST7735_GMCTRN1 0xE1
+
+/* some RGB color definitions                                                 */
+#define Black           0x0000      /*   0,   0,   0 */
+#define Navy            0x000F      /*   0,   0, 128 */
+#define DarkGreen       0x03E0      /*   0, 128,   0 */
+#define DarkCyan        0x03EF      /*   0, 128, 128 */
+#define Maroon          0x7800      /* 128,   0,   0 */
+#define Purple          0x780F      /* 128,   0, 128 */
+#define Olive           0x7BE0      /* 128, 128,   0 */
+#define LightGrey       0xC618      /* 192, 192, 192 */
+#define DarkGrey        0x7BEF      /* 128, 128, 128 */
+#define Blue            0x001F      /*   0,   0, 255 */
+#define Green           0x07E0      /*   0, 255,   0 */
+#define Cyan            0x07FF      /*   0, 255, 255 */
+#define Red             0xF800      /* 255,   0,   0 */
+#define Magenta         0xF81F      /* 255,   0, 255 */
+#define Yellow          0xFFE0      /* 255, 255,   0 */
+#define White           0xFFFF      /* 255, 255, 255 */
+#define Orange          0xFD20      /* 255, 165,   0 */
+#define GreenYellow     0xAFE5      /* 173, 255,  47 */
+
+class ST7735_TFT : public GraphicsDisplay {
+ public:
+
+  /** Create a ST7735_TFT object connected to SPI and three pins. ST7735 requires rs pin to toggle between data/command
+   *
+   * @param mosi,miso,sclk SPI
+   * @param cs pin connected to CS of display (called SS for 'Slave Select' in ST7735 datasheet)
+   * @param rs pin connected to RS of display (called D/CX in ST7735 datasheet)
+   * @param reset pin connected to RESET of display
+   *
+   */ 
+  ST7735_TFT(PinName mosi, PinName miso, PinName sclk, PinName cs, PinName rs, PinName reset,const char* name ="TFT");
+    
+  /** Get the width of the screen in pixel
+   *
+   * @param 
+   * @returns width of screen in pixel
+   *
+   */    
+  virtual int width();
+
+  /** Get the height of the screen in pixel
+   *
+   * @returns height of screen in pixel 
+   *
+   */     
+  virtual int height();
+    
+  /** Draw a pixel at x,y with color 
+   *  
+   * @param x horizontal position
+   * @param y vertical position
+   * @param color 16 bit pixel color
+   */    
+  virtual void pixel(int x, int y, int colour);
+   
+  /** Get colour of pixel at x,y 
+   *  
+   * @param x horizontal position
+   * @param y vertical position
+   */    
+  
+  int getpixel(unsigned int x, unsigned int y);
+      
+  /** draw a circle
+   *
+   * @param x0,y0 center
+   * @param r radius
+   * @param color 16 bit color                                                                 *
+   *
+   */
+       
+  void circle(int x, int y, int r, int colour); 
+  
+  /** draw a filled circle
+   *
+   * @param x0,y0 center
+   * @param r radius
+   * @param color 16 bit color                                                                 *
+   *
+   * use circle with different radius,
+   * can miss some pixel
+   */    
+  void fillcircle(int x, int y, int r, int colour); 
+  
+  /** draw a 1 pixel line
+   *
+   * @param x0,y0 start point
+   * @param x1,y1 stop point
+   * @param color 16 bit color
+   *
+   */    
+  void line(int x0, int y0, int x1, int y1, int colour);
+    
+  /** draw a rect
+   *
+   * @param x0,y0 top left corner
+   * @param x1,y1 down right corner
+   * @param color 16 bit color
+   *                                                   *
+   */    
+  void rect(int x0, int y0, int x1, int y1, int colour);
+    
+  /** draw a filled rect
+   *
+   * @param x0,y0 top left corner
+   * @param x1,y1 down right corner
+   * @param color 16 bit color
+   *
+   */    
+  void fillrect(int x0, int y0, int x1, int y1, int colour);
+    
+  /** setup cursor position
+   *
+   * @param x x-position (top left)
+   * @param y y-position 
+   */   
+  void locate(int x, int y);
+    
+  /** Fill the screen with _backgroun color
+   *
+   */   
+  virtual void cls (void);   
+    
+  /** calculate the max number of char in a line
+   *
+   * @returns max columns
+   * depends on actual font size
+   *
+   */    
+  int columns(void);
+    
+  /** calculate the max number of columns
+   *
+   * @returns max column
+   * depends on actual font size
+   *
+   */   
+  int rows(void);
+    
+  /** put a char on the screen
+   *
+   * @param value char to print
+   * @returns printed char
+   *
+   */
+  int _putc(int value);
+    
+  /** draw a character on given position out of the active font to the TFT
+   *
+   * @param x x-position of char (top left) 
+   * @param y y-position
+   * @param c char to print
+   *
+   */    
+  virtual void character(int x, int y, int c);
+    
+  /** paint a bitmap on the TFT 
+   *
+   * @param x,y : upper left corner 
+   * @param w width of bitmap
+   * @param h high of bitmap
+   * @param *bitmap pointer to the bitmap data
+   *
+   *   bitmap format: 16 bit R5 G6 B5
+   * 
+   *   use Gimp to create / load , save as BMP, option 16 bit R5 G6 B5            
+   *   use winhex to load this file and mark data stating at offset 0x46 to end
+   *   use edit -> copy block -> C Source to export C array
+   *   paste this array into your program
+   * 
+   *   define the array as static const unsigned char to put it into flash memory
+   *   cast the pointer to (unsigned char *) :
+   *   tft.Bitmap(10,40,309,50,(unsigned char *)scala);
+   */    
+  void Bitmap(unsigned int x, unsigned int y, unsigned int w, unsigned int h,unsigned char *bitmap);
+    
+    
+   /** paint a 16 bit BMP from local filesytem on the TFT (slow) 
+   *
+   * @param x,y : upper left corner 
+   * @param *Name_BMP name of the BMP file
+   * @returns 1 if bmp file was found and painted
+   * @returns -1 if bmp file was found not found
+   * @returns -2 if bmp file is not 16bit
+   * @returns -3 if bmp file is to big for screen 
+   * @returns -4 if buffer malloc go wrong
+   *
+   *   bitmap format: 16 bit R5 G6 B5
+   * 
+   *   use Gimp to create / load , save as BMP, option 16 bit R5 G6 B5
+   *   copy to internal file system            
+   * 
+   */      
+    
+  int BMP_16(unsigned int x, unsigned int y, const char *Name_BMP);  
+    
+   /** Read an area from the LCD RAM to MCU RAM
+   *
+   * @param x,y : upper left corner 
+   * @param w width of bitmap
+   * @param h high of bitmap
+   * @param *buffer pointer to the buffer
+   */    
+
+  void read_area(unsigned int x, unsigned int y, unsigned int w, unsigned int h,unsigned char *buffer);  
+    
+  /** select the font to use
+   *
+   * @param f pointer to font array 
+   *                                                                              
+   *   font array can created with GLCD Font Creator from http://www.mikroe.com
+   *   you have to add 4 parameter at the beginning of the font array to use: 
+   *   - the number of byte / char
+   *   - the vertial size in pixel
+   *   - the horizontal size in pixel
+   *   - the number of byte per vertical line
+   *   you also have to change the array to char[]
+   *
+   */  
+  void set_font(unsigned char* f);
+   
+  /** Set the orientation of the screen
+   *  x,y: 0,0 is always top left 
+   *
+   * @param o direction to use the screen (0-3) 90&#65533; Steps  
+   *
+   */  
+  void set_orientation(unsigned int o);
+    
+  SPI _spi;
+  DigitalOut _cs;
+  DigitalOut _rs;
+  DigitalOut _reset;
+  unsigned char* font;
+   
+protected:
+
+  /** draw a horizontal line
+   *
+   * @param x0 horizontal start
+   * @param x1 horizontal stop
+   * @param y vertical position
+   * @param color 16 bit color                                               
+   *
+   */
+  void hline(int x0, int x1, int y, int colour);
+    
+  /** draw a vertical line
+   *
+   * @param x horizontal position
+   * @param y0 vertical start 
+   * @param y1 vertical stop
+   * @param color 16 bit color
+   */
+  void vline(int y0, int y1, int x, int colour);
+    
+  /** Set draw window region
+   *
+   * @param x horizontal position
+   * @param y vertical position
+   * @param w window width in pixel
+   * @param h window height in pixels
+   */    
+  void window (unsigned int x, unsigned int y, unsigned int w, unsigned int h);
+    
+  /** Set draw window region to whole screen
+   *
+   */  
+  void WindowMax (void);
+    
+  /** Init the ST7735 controller
+   *
+   */    
+  void tft_reset();
+    
+   /** Write data to the LCD controller
+   *
+   * @param dat data written to LCD controller
+   * 
+   */   
+  void wr_dat(int value);
+    
+  /** Write a command the LCD controller 
+   *
+   * @param cmd: command to be written   
+   *
+   */   
+  void wr_cmd(int value);
+    
+   /** Start data sequence to the LCD controller
+   * 
+   */   
+  void wr_dat_start();
+    
+  /** Stop of data writing to the LCD controller
+   *   
+   */  
+  void wr_dat_stop();
+    
+  /** write data to the LCD controller
+   *
+   * @param data to be written 
+   *                                           *
+   */    
+  void wr_dat_only(unsigned short dat);
+    
+  /** Read data from the LCD controller
+   *
+   * @returns data from LCD controller
+   *  
+   */    
+  unsigned short rd_dat(void);
+    
+  /** Write a value to the to a LCD register
+   *
+   * @param reg register to be written
+   * @param val data to be written
+   */   
+  void wr_reg (unsigned char reg, unsigned short val);
+    
+  /** Read a LCD register
+   *
+   * @param reg register to be read
+   * @returns value of the register 
+   */    
+  unsigned short rd_reg (unsigned char reg);
+        
+  unsigned int orientation;
+  unsigned int char_x;
+  unsigned int char_y;
+ 
+    
+};
+
+#endif
diff -r 000000000000 -r 0c777a879891 TextDisplay.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TextDisplay.cpp	Tue Aug 27 14:31:22 2013 +0000
@@ -0,0 +1,77 @@
+/* mbed TextDisplay Display Library Base Class
+ * Copyright (c) 2007-2009 sford
+ * Released under the MIT License: http://mbed.org/license/mit
+ */
+ 
+#include "TextDisplay.h"
+
+TextDisplay::TextDisplay(const char *name) : Stream(name){
+    _row = 0;
+    _column = 0;
+    if (name == NULL) {
+        _path = NULL;
+    } else {
+        _path = new char[strlen(name) + 2];
+        sprintf(_path, "/%s", name);
+    }
+}
+    
+int TextDisplay::_putc(int value) {
+    if(value == '\n') {
+        _column = 0;
+        _row++;
+        if(_row >= rows()) {
+            _row = 0;
+        }
+    } else {
+        character(_column, _row, value);
+        _column++;
+        if(_column >= columns()) {
+            _column = 0;
+            _row++;
+            if(_row >= rows()) {
+                _row = 0;
+            }
+        }
+    }
+    return value;
+}
+
+// crude cls implementation, should generally be overwritten in derived class
+void TextDisplay::cls() {
+    locate(0, 0);
+    for(int i=0; i<columns()*rows(); i++) {
+        putc(' ');
+    }
+}
+
+void TextDisplay::locate(int column, int row) {
+    _column = column;
+    _row = row;
+}
+
+int TextDisplay::_getc() {
+    return -1;
+}
+        
+void TextDisplay::foreground(uint16_t colour) {
+    _foreground = colour;
+}
+
+void TextDisplay::background(uint16_t colour) {
+    _background = colour;
+}
+
+bool TextDisplay::claim (FILE *stream) {
+    if ( _path == NULL) {
+        fprintf(stderr, "claim requires a name to be given in the instantioator of the TextDisplay instance!\r\n");
+        return false;
+    }
+    if (freopen(_path, "w", stream) == NULL) {
+        // Failed, should not happen
+        return false;
+    }
+    // make sure we use line buffering
+    setvbuf(stdout, NULL, _IOLBF, columns());
+    return true;
+} 
diff -r 000000000000 -r 0c777a879891 TextDisplay.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TextDisplay.h	Tue Aug 27 14:31:22 2013 +0000
@@ -0,0 +1,80 @@
+/* mbed TextDisplay Library Base Class
+ * Copyright (c) 2007-2009 sford
+ * Released under the MIT License: http://mbed.org/license/mit
+ *
+ * A common base class for Text displays
+ * To port a new display, derive from this class and implement
+ * the constructor (setup the display), character (put a character
+ * at a location), rows and columns (number of rows/cols) functions.
+ * Everything else (locate, printf, putc, cls) will come for free
+ *
+ * The model is the display will wrap at the right and bottom, so you can
+ * keep writing and will always get valid characters. The location is 
+ * maintained internally to the class to make this easy
+ */
+
+#ifndef MBED_TEXTDISPLAY_H
+#define MBED_TEXTDISPLAY_H
+
+#include "mbed.h"
+
+class TextDisplay : public Stream {
+public:
+
+  // functions needing implementation in derived implementation class
+  /** Create a TextDisplay interface
+     *
+     * @param name The name used in the path to access the strean through the filesystem
+     */
+    TextDisplay(const char *name = NULL);
+
+    /** output a character at the given position
+     *
+     * @param column column where charater must be written
+     * @param  row where character must be written
+     * @param c the character to be written to the TextDisplay
+     */
+    virtual void character(int column, int row, int c) = 0;
+
+    /** return number if rows on TextDisplay
+     * @result number of rows
+     */
+    virtual int rows() = 0;
+
+    /** return number if columns on TextDisplay
+    * @result number of rows
+    */
+    virtual int columns() = 0;
+    
+    // functions that come for free, but can be overwritten
+
+    /** redirect output from a stream (stoud, sterr) to  display
+    * @param stream stream that shall be redirected to the TextDisplay
+    */
+    virtual bool claim (FILE *stream);
+
+    /** clear screen
+    */
+    virtual void cls();
+    virtual void locate(int column, int row);
+    virtual void foreground(uint16_t colour);
+    virtual void background(uint16_t colour);
+    // putc (from Stream)
+    // printf (from Stream)
+    
+protected:
+
+    virtual int _putc(int value);
+    virtual int _getc();
+
+    // character location
+    uint16_t _column;
+    uint16_t _row;
+
+    // colours
+    uint16_t _foreground;
+    uint16_t _background;
+    char *_path;
+};
+
+#endif
diff -r 000000000000 -r 0c777a879891 WiiChuck.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/WiiChuck.lib	Tue Aug 27 14:31:22 2013 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/FrankWeissenborn/code/WiiChuck/#9169c602b0d8
diff -r 000000000000 -r 0c777a879891 main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Tue Aug 27 14:31:22 2013 +0000
@@ -0,0 +1,48 @@
+#include "mbed.h"
+#include "ST7735_TFT.h"
+#include "WiiChuck.h"
+/*
+2013.Aug.27
+Wiichuck is NOT compatible with latest mbed library
+it is ok with revision 39 or older
+*/
+WiiChuck WiiNun(p9, p10);
+ST7735_TFT TFT(p11, NC, p13, p14, p12, p23,"TFT"); // mosi, (miso,) sclk, cs, rs, reset
+Serial pc(USBTX,USBRX);
+
+int main()
+{
+
+    int joyX = 0;
+    int joyY = 0;
+    int accX = 0;
+    int accY = 0;
+    int accZ = 0;
+    int buttonC = 0;
+    int buttonZ = 0;
+
+    TFT.background(Black);    // set background to black
+    TFT.foreground(White);    // set chars to white
+    TFT.set_orientation(3);
+    TFT.cls();                // clear the screen
+//     TFT.set_font((unsigned char*) Arial12x12);  // select the font
+
+//     TFT.set_orientation(0);
+    //TFT.locate(0,0);
+    //TFT.fillrect(10,100,12,150,White);
+    while(1) {
+        bool read = WiiNun.Read(&joyX,&joyY,&accX,&accY,&accZ,&buttonC,&buttonZ);
+        if(read) {
+            pc.printf("x%3d y%3d c%1d z%1d ------", joyX>>1, joyY>>1, buttonC, buttonZ);
+            pc.printf("x%d y%d z%d\n\r", accX, accY, accZ);
+            if(buttonC!=0){
+                TFT.cls();
+            }
+            TFT.fillrect(joyX>>1,128-(joyY>>1),10+(joyX>>1) ,10+128-(joyY>>1),White);
+            //TFT.fillrect(10,100,12,150,White);
+        } else {
+            printf("Error\n");
+        }
+        wait(0.01);
+    }
+}
diff -r 000000000000 -r 0c777a879891 mbed.bld
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Tue Aug 27 14:31:22 2013 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed/builds/737756e0b479
\ No newline at end of file