Revision 0:0c777a879891, committed 2013-08-27

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

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