Revision 0:4bbc531be6e2, committed 2012-10-16

Comitter:

dreschpe

Date:

Tue Oct 16 14:05:57 2012 +0000

Child:

1:66dd8afbfd06

Commit message:

version 1.0

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/C12832_lcd.cpp	Tue Oct 16 14:05:57 2012 +0000
@@ -0,0 +1,577 @@
+/* mbed library for the mbed Lab Board  128*32 pixel LCD
+ * use C12832 controller
+ * Copyright (c) 2012 Peter Drescher - DC2PD
+ * Released under the MIT License: http://mbed.org/license/mit
+ *
+ * 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.
+ */
+
+// 13.10.12    initial design
+// optional defines :
+#define debug_lcd  1
+
+#include "C12832_lcd.h"
+#include "mbed.h"
+#include "stdio.h"
+
+#define BPP    1       // Bits per pixel
+
+C12832_LCD::C12832_LCD(const char* name)
+    : _spi(p5,NC,p7),_reset(p6),_A0(p8),_CS(p11),GraphicsDisplay(name)
+{
+    orientation = 1;
+    draw_mode = NORMAL;
+    char_x = 0;
+    lcd_reset();
+}
+
+int C12832_LCD::width()
+{
+    if (orientation == 0 || orientation == 2) return 32;
+    else return 128;
+}
+
+int C12832_LCD::height()
+{
+    if (orientation == 0 || orientation == 2) return 128;
+    else return 32;
+}
+
+
+void C12832_LCD::set_orientation(unsigned int o)
+{
+    orientation = o;
+    switch (o) {
+        case (0):
+            wr_cmd(0xA0);
+            wr_cmd(0xC0);
+            break;
+        case (1):
+            wr_cmd(0xA0);
+            wr_cmd(0xC8);
+            break;
+        case (2):
+            wr_cmd(0xA1);
+            wr_cmd(0xC8);
+            break;
+        case (3):
+            wr_cmd(0xA1);
+            wr_cmd(0xC0);
+            break;
+    }
+}
+
+void C12832_LCD::invert(unsigned int o)
+{
+    if(o == 0) wr_cmd(0xA6);
+    else wr_cmd(0xA7);
+}
+
+
+void C12832_LCD::set_contrast(unsigned int o)
+{
+    wr_cmd(0x81);      //  set volume
+    wr_cmd(o & 0x2F);
+}
+
+
+// write command to lcd controller
+
+void C12832_LCD::wr_cmd(unsigned char cmd)
+{
+    _A0 = 0;
+    _CS = 0;
+    LPC_SSP1->DR = cmd;
+    do {
+    } while ((LPC_SSP1->SR & 0x10) == 0x10); // wait for SPI1 idle
+    _CS = 1;
+}
+
+// write data to lcd controller
+
+void C12832_LCD::wr_dat(unsigned char dat)
+{
+    _A0 = 1;
+    _CS = 0;
+    LPC_SSP1->DR = dat;
+    do {
+    } while ((LPC_SSP1->SR & 0x10) == 0x10); // wait for SPI1 idle
+    _CS = 1;
+}
+
+// reset and init the lcd controller
+
+void C12832_LCD::lcd_reset()
+{
+
+    _spi.format(8,3);                 // 8 bit spi mode 3
+    _spi.frequency(20000000);          // 19,2 Mhz SPI clock
+    DigitalOut _reset(p6);
+    _A0 = 0;
+    _CS = 1;
+    _reset = 0;                        // display reset
+    wait_us(50);
+    _reset = 1;                       // end reset
+    wait_ms(5);
+
+    /* Start Initial Sequence ----------------------------------------------------*/
+
+    wr_cmd(0xAE);   //  display off
+    wr_cmd(0xA2);   //  bias voltage
+
+    wr_cmd(0xA0);
+    wr_cmd(0xC8);   //  colum normal
+
+    wr_cmd(0x22);   //  voltage resistor ratio
+    wr_cmd(0x2F);   //  power on
+    wr_cmd(0xA4);   //  LCD display ram
+    wr_cmd(0x40);   // start line = 0
+    wr_cmd(0xAF);     // display ON
+
+    wr_cmd(0x81);   //  set contrast
+    wr_cmd(0x17);   //  set contrast
+
+    wr_cmd(0xA6);     // display normal
+
+    //setup DMA channel 0
+    LPC_SC->PCONP |= (1UL << 29);   // Power up the GPDMA
+    LPC_GPDMA->DMACConfig = 1;          // enable DMA controller
+    LPC_GPDMA->DMACIntTCClear = 0x1;
+    LPC_GPDMA->DMACIntErrClr = 0x1;
+    LPC_GPDMACH0->DMACCLLI = 0;
+    // clear and update LCD
+    memset(buffer,0x00,512);  // clear display buffer
+    copy_to_lcd();
+}
+
+// set one pixel in buffer
+
+void C12832_LCD::pixel(int x, int y, int color)
+{
+    // first check parameter
+    if(x > 128 || y > 32 || x < 0 || y < 0) return;
+
+    if(draw_mode == NORMAL) {
+        if(color == 0)
+            buffer[x + ((y/8) * 128)] &= ~(1 << (y%8));  // erase pixel
+        else
+            buffer[x + ((y/8) * 128)] |= (1 << (y%8));   // set pixel
+    } else { // XOR mode
+        if(color == 1)
+            buffer[x + ((y/8) * 128)] ^= (1 << (y%8));   // xor pixel
+    }
+}
+
+// update lcd
+
+void C12832_LCD::copy_to_lcd(void)
+{
+    //page 0
+    wr_cmd(0x00);      // set column low nibble 0
+    wr_cmd(0x10);      // set column hi  nibble 0
+    wr_cmd(0xB0);      // set page address  0
+    _CS = 0;
+    _A0 = 1;
+    // start 128 byte DMA transfer to SPI1
+    LPC_GPDMACH0->DMACCDestAddr = (uint32_t)&LPC_SSP1->DR; // we send to SSP1
+    LPC_SSP1->DMACR = 0x2;  // Enable SSP1 for DMA.
+    LPC_GPDMA->DMACIntTCClear = 0x1;
+    LPC_GPDMA->DMACIntErrClr = 0x1;
+    LPC_GPDMACH0->DMACCSrcAddr = (uint32_t) (buffer);
+    LPC_GPDMACH0->DMACCControl = 128 | (1UL << 31) |  DMA_CHANNEL_SRC_INC ; // 8 bit transfer , address increment, interrupt
+    LPC_GPDMACH0->DMACCConfig  = DMA_CHANNEL_ENABLE | DMA_TRANSFER_TYPE_M2P | DMA_DEST_SSP1_TX;
+    LPC_GPDMA->DMACSoftSReq = 0x1;
+    do {
+    } while ((LPC_GPDMA->DMACRawIntTCStat & 0x01) == 0); // DMA is running
+    do {
+    } while ((LPC_SSP1->SR & 0x10) == 0x10); // SPI1 not idle
+    _CS = 1;
+
+    // page 1
+    wr_cmd(0x00);      // set column low nibble 0
+    wr_cmd(0x10);      // set column hi  nibble 0
+    wr_cmd(0xB1);      // set page address  1
+    _CS = 0;
+    _A0 = 1;
+    // start 128 byte DMA transfer to SPI1
+    LPC_GPDMA->DMACIntTCClear = 0x1;
+    LPC_GPDMA->DMACIntErrClr = 0x1;
+    LPC_GPDMACH0->DMACCSrcAddr = (uint32_t) (buffer + 128);
+    LPC_GPDMACH0->DMACCControl = 128 | (1UL << 31) |  DMA_CHANNEL_SRC_INC ; // 8 bit transfer , address increment, interrupt
+    LPC_GPDMACH0->DMACCConfig  = DMA_CHANNEL_ENABLE | DMA_TRANSFER_TYPE_M2P | DMA_DEST_SSP1_TX;
+    LPC_GPDMA->DMACSoftSReq = 0x1;
+    do {
+    } while ((LPC_GPDMA->DMACRawIntTCStat & 0x01) == 0); // DMA is running
+    do {
+    } while ((LPC_SSP1->SR & 0x10) == 0x10); // SPI1 not idle
+    _CS = 1;
+
+    //page 2
+    wr_cmd(0x00);      // set column low nibble 0
+    wr_cmd(0x10);      // set column hi  nibble 0
+    wr_cmd(0xB2);      // set page address  2
+    _CS = 0;
+    _A0 = 1;
+    // start 128 byte DMA transfer to SPI1
+    LPC_GPDMA->DMACIntTCClear = 0x1;
+    LPC_GPDMA->DMACIntErrClr = 0x1;
+    LPC_GPDMACH0->DMACCSrcAddr = (uint32_t) (buffer + 256);
+    LPC_GPDMACH0->DMACCControl = 128 | (1UL << 31) |  DMA_CHANNEL_SRC_INC ; // 8 bit transfer , address increment, interrupt
+    LPC_GPDMACH0->DMACCConfig  = DMA_CHANNEL_ENABLE | DMA_TRANSFER_TYPE_M2P | DMA_DEST_SSP1_TX ;
+    LPC_GPDMA->DMACSoftSReq = 0x1;
+    do {
+    } while ((LPC_GPDMA->DMACRawIntTCStat & 0x01) == 0); // DMA is running
+    do {
+    } while ((LPC_SSP1->SR & 0x10) == 0x10); // SPI1 not idle
+    _CS = 1;
+    
+    //page 3
+    wr_cmd(0x00);      // set column low nibble 0
+    wr_cmd(0x10);      // set column hi  nibble 0
+    wr_cmd(0xB3);      // set page address  3
+    _CS = 0;
+    _A0 = 1;
+    // start 128 byte DMA transfer to SPI1
+    LPC_GPDMA->DMACIntTCClear = 0x1;
+    LPC_GPDMA->DMACIntErrClr = 0x1;
+    LPC_GPDMACH0->DMACCSrcAddr = (uint32_t) (buffer + 384);
+    LPC_GPDMACH0->DMACCControl = 128  | (1UL << 31) |  DMA_CHANNEL_SRC_INC ; // 8 bit transfer , address increment, interrupt
+    LPC_GPDMACH0->DMACCConfig  = DMA_CHANNEL_ENABLE | DMA_TRANSFER_TYPE_M2P | DMA_DEST_SSP1_TX;
+    LPC_GPDMA->DMACSoftSReq = 0x1;
+    do {
+    } while ((LPC_GPDMA->DMACRawIntTCStat & 0x01) == 0); // DMA is running
+    do {
+    } while ((LPC_SSP1->SR & 0x10) == 0x10); // SPI1 not idle
+    _CS = 1;
+}
+
+void C12832_LCD::cls(void)
+{
+    memset(buffer,0x00,512);  // clear display buffer
+    copy_to_lcd();
+}
+
+
+void C12832_LCD::line(int x0, int y0, int x1, int y1, int color)
+{
+    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 C12832_LCD::rect(int x0, int y0, int x1, int y1, int color)
+{
+
+    if (x1 > x0) line(x0,y0,x1,y0,color);
+    else  line(x1,y0,x0,y0,color);
+
+    if (y1 > y0) line(x0,y0,x0,y1,color);
+    else line(x0,y1,x0,y0,color);
+
+    if (x1 > x0) line(x0,y1,x1,y1,color);
+    else  line(x1,y1,x0,y1,color);
+
+    if (y1 > y0) line(x1,y0,x1,y1,color);
+    else line(x1,y1,x1,y0,color);
+
+    return;
+}
+
+void C12832_LCD::fillrect(int x0, int y0, int x1, int y1, int color)
+{
+    int l,c,i;
+    if(x0 > x1) {
+        i = x0;
+        x0 = x1;
+        x1 = i;
+    }
+
+    if(y0 > y1) {
+        i = y0;
+        y0 = y1;
+        y1 = i;
+    }
+
+    for(l = x0; l<= x1; l ++) {
+        for(c = y0; c<= y1; c++) {
+            pixel(l,c,color);
+        }
+    }
+}
+
+
+
+void C12832_LCD::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 C12832_LCD::fillcircle(int x, int y, int r, int color)
+{
+    int i;
+    for (i = 0; i <= r; i++)
+        circle(x,y,i,color);
+}
+
+void C12832_LCD::setmode(int mode)
+{
+    draw_mode = mode;
+}
+
+void C12832_LCD::locate(int x, int y)
+{
+    char_x = x;
+    char_y = y;
+}
+
+
+
+int C12832_LCD::columns()
+{
+    return width() / font[1];
+}
+
+
+
+int C12832_LCD::rows()
+{
+    return height() / font[2];
+}
+
+
+
+int C12832_LCD::_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 C12832_LCD::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;
+        }
+    }
+
+    zeichen = &font[((c -32) * offset) + 4]; // start of char bitmap
+    w = zeichen[0];                          // width of actual char
+    // construct the char into the buffer
+    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) {
+                pixel(x+i,y+j,0);
+            } else {
+                pixel(x+i,y+j,1);
+            }
+
+        }
+    }
+
+    char_x += w;
+}
+
+
+void C12832_LCD::set_font(unsigned char* f)
+{
+    font = f;
+}
+
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/C12832_lcd.h	Tue Oct 16 14:05:57 2012 +0000
@@ -0,0 +1,271 @@
+/* mbed library for the mbed Lab Board  128*32 pixel LCD
+ * use C12832 controller
+ * Copyright (c) 2012 Peter Drescher - DC2PD
+ * Released under the MIT License: http://mbed.org/license/mit
+ *
+ * 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 C12832_H
+#define C12832_H
+
+#include "mbed.h"
+#include "GraphicsDisplay.h"
+
+
+/** optional Defines : 
+  * #define debug_lcd  1  enable infos to PC_USB
+  */
+
+// some defines for the DMA use
+#define DMA_CHANNEL_ENABLE      1
+#define DMA_TRANSFER_TYPE_M2P   (1UL << 11)
+#define DMA_CHANNEL_TCIE        (1UL << 31)
+#define DMA_CHANNEL_SRC_INC     (1UL << 26)
+#define DMA_MASK_IE             (1UL << 14)
+#define DMA_MASK_ITC            (1UL << 15)
+#define DMA_SSP1_TX             (1UL << 2)
+#define DMA_SSP0_TX             (0)
+#define DMA_DEST_SSP1_TX        (2UL << 6)
+#define DMA_DEST_SSP0_TX        (0UL << 6)
+
+ /** Draw mode
+   * NORMAl 
+   * XOR set pixel by xor the screen
+   */  
+enum {NORMAL,XOR};
+
+class C12832_LCD : public GraphicsDisplay
+{
+public:
+    /** Create a C12832_LCD object connected to SPI1
+      *
+      */
+
+    C12832_LCD(const char* name = "LCD");
+
+    /** 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 black or white
+     *
+     * @param x horizontal position
+     * @param y vertical position
+     * @param colour ,1 set pixel ,0 erase pixel
+     */
+    virtual void pixel(int x, int y,int colour);
+
+    /** draw a circle
+      *
+      * @param x0,y0 center
+      * @param r radius
+      * @param colour ,1 set pixel ,0 erase pixel
+      *
+      */
+    void circle(int x, int y, int r, int colour);
+
+    /** draw a filled circle
+     *
+     * @param x0,y0 center
+     * @param r radius
+     * @param color ,1 set pixel ,0 erase pixel
+     *
+     * 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 ,1 set pixel ,0 erase pixel
+      *
+      */
+    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 1 set pixel ,0 erase pixel
+   *                                                   *
+   */    
+  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 1 set pixel ,0 erase pixel
+   *
+   */    
+  void fillrect(int x0, int y0, int x1, int y1, int colour);   
+    
+    /** copy display buffer to lcd 
+      *
+      */
+        
+    void copy_to_lcd(void);
+
+    /** set the orienation of the screen
+     *
+     */
+
+    void set_orientation(unsigned int o);
+
+/** set the contrast of the screen
+     *
+     */
+
+    void set_contrast(unsigned int o);
+    
+/** invert the screen 
+  *
+  * @param o = 0 normal, 1 invert
+  */     
+    void invert(unsigned int o);
+    
+/** clear the screen 
+   *
+   */      
+   virtual void cls(void);
+   
+/** set the drawing mode
+  *  
+  * @param mode NORMAl or XOR
+  */
+   
+void setmode(int mode);
+   
+   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 LCD
+   *
+   * @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);
+  
+  /** setup cursor position
+   *
+   * @param x x-position (top left)
+   * @param y y-position 
+   */   
+  void locate(int x, int y);
+   
+
+    /** Vars     */
+    SPI _spi;
+    DigitalOut _reset;
+    DigitalOut _A0;
+    DigitalOut _CS;
+    unsigned char* font;
+    unsigned int draw_mode;
+
+
+ /** 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);
+
+
+protected:
+
+    /** draw a horizontal line
+      *
+      * @param x0 horizontal start
+      * @param x1 horizontal stop
+      * @param y vertical position
+      * @param ,1 set pixel ,0 erase pixel
+      *
+      */
+    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 ,1 set pixel ,0 erase pixel
+     */
+    void vline(int y0, int y1, int x, int colour);
+
+    /** Init the C12832 LCD controller
+     *
+     */
+    void lcd_reset();
+
+    /** Write data to the LCD controller
+     *
+     * @param dat data written to LCD controller
+     *
+     */
+    void wr_dat(unsigned char value);
+
+    /** Write a command the LCD controller
+      *
+      * @param cmd: command to be written
+      *
+      */
+    void wr_cmd(unsigned char value);
+    
+    void wr_cnt(unsigned char cmd);
+
+    unsigned int orientation;
+    unsigned int char_x;
+    unsigned int char_y;
+    unsigned char buffer[512];
+
+};
+
+
+
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/GraphicsDisplay.cpp	Tue Oct 16 14:05:57 2012 +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; 
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/GraphicsDisplay.h	Tue Oct 16 14:05:57 2012 +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

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TextDisplay.cpp	Tue Oct 16 14:05:57 2012 +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;
+} 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TextDisplay.h	Tue Oct 16 14:05:57 2012 +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