Revision 0:ff072ee9597c, committed 2010-10-03

Comitter:

Lerche

Date:

Sun Oct 03 08:40:47 2010 +0000

Commit message:

Changed in this revision

diff -r 000000000000 -r ff072ee9597c EAOLED.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/EAOLED.cpp	Sun Oct 03 08:40:47 2010 +0000
@@ -0,0 +1,390 @@
+// test library for Embedded Artists OLED used on Xpresso Baseboard
+
+#include "EAOLED.h"
+#include "mbed.h"
+
+EAOLED::EAOLED(PinName mosi, PinName dnc, PinName sclk, PinName cs, PinName power) 
+    : _spi(mosi, NC, sclk), _data(dnc), _cs(cs), _power(power) {
+    reset();    
+}
+      
+void EAOLED::command(int value) {
+    _data = 0;
+    _cs = 0;
+    _spi.write(value);
+    _cs = 1;
+}
+
+void EAOLED::data(int value) {
+    _data = 1;
+    _cs = 0;
+    _spi.write(value);
+    _cs = 1;
+}
+
+void EAOLED::reset() {
+    _power = 0;
+    _cs = 1;
+
+    // Startup sequence recommended by embedded artists baseboard reference code
+    command(0x02); // set low column address
+    command(0x12); // set high column address
+    command(0x40); // display start set
+    command(0x2e); // stop horzontal scroll
+    command(0x81); // set contrast control register
+    command(0x32); //
+    command(0x82); // brightness for color banks
+    command(0x80); // display on
+    command(0xa1); // set segment re-map
+    command(0xa6); // set normal/inverse display
+    command(0xa8); // set multiplex ratio
+    command(0x3F); //
+    command(0xd3); // set display offset
+    command(0x40); //
+    command(0xad); // set dc-dc on/off
+    command(0x8E); //
+    command(0xc8); // set com output scan direction
+    command(0xd5); // set display clock divide ratio/oscillator/frequency
+    command(0xf0); //
+    command(0xd8); // set area color mode on/off & low power display mode 
+    command(0x05); //
+    command(0xd9); // set pre-charge period
+    command(0xF1); //
+    command(0xda); // set com pins hardware configuration
+    command(0x12); //
+    command(0xdb); // set vcom deselect level
+    command(0x34); //
+    command(0x91); // set look up table for area color 
+    command(0x3f); //
+    command(0x3f); //
+    command(0x3f); //
+    command(0x3f); //
+    command(0xaf); // display on
+    command(0xa4); // display on
+
+    wait_us(10);
+
+    _power = 1;
+}
+
+#define OLED_DISPLAY_WIDTH  96
+#define OLED_DISPLAY_HEIGHT 64
+
+void EAOLED::pixel(int x, int y, int colour) {
+    int page = y >> 3;
+    int address = 18 + x;
+    
+    int lo = (address >> 0) & 0x0F;
+    int hi =  (address >> 4) | 0x10;
+    int mask = 1 << (y & 0x7);
+    int byte = page * OLED_DISPLAY_WIDTH + x;
+    
+    if(colour) {
+        framebuffer[byte] |= mask;
+    } else {
+        framebuffer[byte] &= ~mask;
+    }
+
+    command(0xB0 + page);
+    command(lo);
+    command(hi);
+    data(framebuffer[byte]);
+}
+
+void EAOLED::circle(int x0, int y0, int r, int colour) {
+
+#define OLED_DISPLAY_WIDTH  96
+#define OLED_DISPLAY_HEIGHT 64
+
+    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;    
+
+    if(r == 0)          /* no radius */
+    {
+        return;
+    }
+
+    draw_x0 = draw_x1 = x0;
+    draw_y0 = draw_y1 = y0 + r;
+    if(draw_y0 < OLED_DISPLAY_HEIGHT)
+    {
+        pixel(draw_x0, draw_y0, colour);     /* 90 degree */
+    }
+
+    draw_x2 = draw_x3 = x0;
+    draw_y2 = draw_y3 = y0 - r;
+    if(draw_y2 >= 0)
+    {
+        pixel(draw_x2, draw_y2, colour);    /* 270 degree */
+    }
+    
+    draw_x4 = draw_x6 = x0 + r;
+    draw_y4 = draw_y6 = y0;
+    if(draw_x4 < OLED_DISPLAY_WIDTH)
+    {
+        pixel(draw_x4, draw_y4, colour);     /* 0 degree */
+    }    
+    
+    draw_x5 = draw_x7 = x0 - r;
+    draw_y5 = draw_y7 = y0;
+    if(draw_x5>=0)
+    {
+        pixel(draw_x5, draw_y5, colour);     /* 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 <= OLED_DISPLAY_WIDTH) && (draw_y0>=0) )
+        {
+            pixel(draw_x0, draw_y0, colour);
+        }
+
+        if( (draw_x1 >= 0) && (draw_y1 >= 0) )
+        {
+            pixel(draw_x1, draw_y1, colour);
+        }
+
+        if( (draw_x2 <= OLED_DISPLAY_WIDTH) && (draw_y2 <= OLED_DISPLAY_HEIGHT) )
+        {
+            pixel(draw_x2, draw_y2, colour);
+        }
+
+        if( (draw_x3 >=0 ) && (draw_y3 <= OLED_DISPLAY_HEIGHT) )
+        {
+            pixel(draw_x3, draw_y3, colour);
+        }
+
+        if( (draw_x4 <= /*OLED_DISPLAY_HEIGHT*/OLED_DISPLAY_WIDTH) && (draw_y4 >= 0) )
+        {
+            pixel(draw_x4, draw_y4, colour);
+        }
+
+        if( (draw_x5 >= 0) && (draw_y5 >= 0) )
+        {
+            pixel(draw_x5, draw_y5, colour);
+        }
+        if( (draw_x6 <= OLED_DISPLAY_WIDTH) && (draw_y6 <= OLED_DISPLAY_HEIGHT) )
+        {
+            pixel(draw_x6, draw_y6, colour);
+        }
+        if( (draw_x7 >= 0) && (draw_y7 <= OLED_DISPLAY_HEIGHT) )
+        {
+            pixel(draw_x7, draw_y7, colour);
+        }
+    }
+    return;
+}
+
+void EAOLED::hline(int x0, int x1, int y, int colour) {
+    for(int x=x0; x<x1; x++){
+        pixel(x, y, colour);
+    }
+    return;
+}
+
+void EAOLED::vline(int y0, int y1, int x, int colour) {
+    for(int y=y0; y<y1; y++){
+        pixel(x, y, colour);
+    }
+    return;
+}
+
+void EAOLED::line(int x0, int y0, int x1, int y1, int colour) {
+    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 */
+    {
+        for(int y=y0; y<y1; y++){
+            pixel(x0, y, colour);
+        }
+        return;
+    }
+
+    if(dx > 0)
+    {
+        dx_sym = 1;
+    }
+    else
+    {
+        dx_sym = -1;
+    }
+
+
+    if(dy == 0)           /* horizontal line */
+    {
+        for(int x=x0; x<x1; x++){
+            pixel(x, y0, colour);
+        }
+        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, colour);
+            x0 += dx_sym;
+            if(di<0)
+            {
+                di += dy_x2;
+            }
+            else
+            {
+                di += dy_x2 - dx_x2;
+                y0 += dy_sym;
+            }
+        }
+        pixel(x0, y0, colour);
+    }
+    else
+    {
+        di = dx_x2 - dy;
+        while(y0 != y1)
+        {
+            pixel(x0, y0, colour);
+            y0 += dy_sym;
+            if(di < 0)
+            {
+                di += dx_x2;
+            }
+            else
+            {
+                di += dx_x2 - dy_x2;
+                x0 += dx_sym;
+            }
+        }
+        pixel(x0, y0, colour);
+    }
+    return;
+}
+
+void EAOLED::rect(int x0, int y0, int x1, int y1, int colour) {
+
+    for(int x=x0; x<x1; x++){
+        pixel(x, y0, colour);
+    }
+    for(int x=x0; x<x1; x++){
+        pixel(x, y1, colour);
+    }
+    for(int y=y0; y<y1; y++){
+        pixel(x0, y, colour);
+    }
+    for(int y=y0; y<y1; y++){
+        pixel(x1, y, colour);
+    }
+    return;
+}
+
+void EAOLED::fillrect(int x0, int y0, int x1, int y1, int colour) {
+
+    int i = 0;
+
+    if(x0 > x1)
+    {
+        i  = x0;
+        x0 = x1;
+        x1 = i;
+    }
+
+    if(y0 > y1)
+    {
+        i  = y0;
+        y0 = y1;
+        y1 = i;
+    }
+
+    if(y0 == y1)
+    {
+        for(int x=x0; x<x1; x++){
+            pixel(x, y0, colour);
+        }
+        return;
+    }
+
+    if(x0 == x1)
+    {
+        for(int y=y0; y<y1; y++){
+            pixel(x0, y, colour);
+        }
+        return;
+    }
+
+    while(y0 <= y1)
+    {
+        for(int x=x0; x<x1; x++){
+            pixel(x, y0, colour);
+        }
+        y0++;
+    }
+    return;
+
+}
\ No newline at end of file

diff -r 000000000000 -r ff072ee9597c EAOLED.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/EAOLED.h	Sun Oct 03 08:40:47 2010 +0000
@@ -0,0 +1,35 @@
+// test library for Embedded Artists OLED used on Xpresso Baseboard
+
+#ifndef MBED_EAOLED_H
+#define MBED_EAOLED_H
+
+#include "mbed.h"
+#include "GraphicsDisplay.h"
+
+class EAOLED : public GraphicsDisplay {
+public:
+    EAOLED(PinName mosi, PinName dnc, PinName sclk, PinName cs, PinName power);
+    virtual void pixel(int x, int y, int colour);
+    virtual void circle(int x, int y, int r, int colour);
+    virtual void hline(int x0, int x1, int y, int colour);
+    virtual void vline(int y0, int y1, int x, int colour);
+    virtual void line(int x0, int y0, int x1, int y1, int colour);
+    virtual void rect(int x0, int y0, int x1, int y1, int colour);
+    virtual void fillrect(int x0, int y0, int x1, int y1, int colour);
+  //  virtual void cls();
+    virtual int width() { return 96; }
+    virtual int height() { return 64; }
+    
+    void reset();
+    void data(int value);
+    void command(int value);
+
+    SPI _spi;
+    DigitalOut _data;
+    DigitalOut _cs;
+    DigitalOut _power;
+    
+    uint8_t framebuffer[(96 * 64) / 8];
+};
+
+#endif

diff -r 000000000000 -r ff072ee9597c GraphicsDisplay.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/GraphicsDisplay.cpp	Sun Oct 03 08:40:47 2010 +0000
@@ -0,0 +1,175 @@
+/* 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() {
+	foreground(0x00FFFFFF);
+	background(0x00000000);
+}
+	
+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 ff072ee9597c GraphicsDisplay.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/GraphicsDisplay.h	Sun Oct 03 08:40:47 2010 +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();
+ 	
+    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 ff072ee9597c TextDisplay.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TextDisplay.cpp	Sun Oct 03 08:40:47 2010 +0000
@@ -0,0 +1,57 @@
+/* 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() {
+    _row = 0;
+    _column = 0;
+}
+    
+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(int colour) {
+    _foreground = colour;
+}
+
+void TextDisplay::background(int colour) {
+    _background = colour;
+}

diff -r 000000000000 -r ff072ee9597c TextDisplay.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TextDisplay.h	Sun Oct 03 08:40:47 2010 +0000
@@ -0,0 +1,52 @@
+/* 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
+    TextDisplay();
+    virtual void character(int column, int row, int c) = 0;
+    virtual int rows() = 0;
+    virtual int columns() = 0;
+    
+    // functions that come for free, but can be overwritten
+    virtual void cls();
+    virtual void locate(int column, int row);
+    virtual void foreground(int colour);
+    virtual void background(int colour);
+    // putc (from Stream)
+    // printf (from Stream)
+    
+protected:
+
+    virtual int _putc(int value);
+    virtual int _getc();
+
+    // character location
+    short _column;
+    short _row;
+
+    // colours
+    int _foreground;
+    int _background;
+};
+
+#endif

diff -r 000000000000 -r ff072ee9597c main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Sun Oct 03 08:40:47 2010 +0000
@@ -0,0 +1,52 @@
+// example to test out OLED on mbed + XPresso baseboard, sford, Lerche
+
+#include "mbed.h"
+#include "EAOLED.h"
+
+// NOTE: The xpresso board does not provide the data/command signal to the mbed, so I added a wire:
+// Connect:
+//  PIO2_7 of baseboard mbed socket (empty 2nd hole below mbed pin 21)
+// to
+//   PIO0_8(p13) of J6 (7th hole down on left side of J6)
+// to provide OLED data/command signal
+
+EAOLED oled(p5, p6, p7, p8, p25); // mosi, dnc, sclk, cs, power
+
+int main() {
+    oled.cls();
+    oled.printf("Hello World!");
+    wait(1);
+    oled.locate(0,5);
+    oled.printf("I'm an OLED!");
+    wait(1);
+    oled.cls();
+    oled.hline(10,50,10,0xFFFFFF);
+    oled.locate(0,5);
+    oled.printf("Horizontal");
+    wait(2);
+    oled.cls();
+    oled.vline(10,30,63,0xFFFFFF);
+    oled.locate(0,5);
+    oled.printf("Vertical");
+    wait(2);
+    oled.cls();
+    oled.line(10,10,40,30,0xFFFFFF);
+    oled.locate(0,5);
+    oled.printf("oblique");
+    wait(2);
+    oled.cls();
+    oled.rect(10,10,30,30,0xFFFFFF);
+    oled.rect(50,5,60,25,0xFFFFFF);
+    oled.locate(0,5);
+    oled.printf("Rectangle");
+    wait(2);
+    oled.cls();
+    oled.fillrect(10,10,30,30,0xFFFFFF);
+    oled.locate(0,5);
+    oled.printf("Filled");
+    wait(2);
+    oled.cls();
+    oled.circle(10,10,7,0xFFFFFF);
+    oled.locate(0,5);
+    oled.printf("Circle");
+}

diff -r 000000000000 -r ff072ee9597c mbed.bld
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Sun Oct 03 08:40:47 2010 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed/builds/49a220cc26e0