Digole Serial Display FRDM-KL25Z Test Program Requires pull-ups on the SDA & SCL data lines. Digole Serial modified with extra Stop commands so that it works with the FRDM-KL25Z I2C library functions. Works fine on LPC1768 without extra Stop commands.

Dependencies:   mbed

Files at this revision

API Documentation at this revision

Comitter:
PhilG1300
Date:
Sat Jun 22 09:33:42 2013 +0000
Commit message:
Digole Serial Display FRDM-KL25Z I2C Test Program

Changed in this revision

DigoleSerialDisplay/DigoleSerialDisp.cpp Show annotated file Show diff for this revision Revisions of this file
DigoleSerialDisplay/DigoleSerialDisp.h Show annotated file Show diff for this revision Revisions of this file
main.cpp Show annotated file Show diff for this revision Revisions of this file
mbed.bld Show annotated file Show diff for this revision Revisions of this file
diff -r 000000000000 -r 535e018f97b9 DigoleSerialDisplay/DigoleSerialDisp.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DigoleSerialDisplay/DigoleSerialDisp.cpp	Sat Jun 22 09:33:42 2013 +0000
@@ -0,0 +1,557 @@
+/** Digole Serial Display library
+ *
+ * @Author: Digole Digital Solutions : www.digole.com ported to mbed by Michael Shimniok www.bot-thoughts.com
+ */
+ 
+#include "mbed.h"
+#include "DigoleSerialDisp.h"
+#include <stdio.h>
+#include <string.h>
+#include <inttypes.h>
+
+char null = 0;
+
+
+// that resetting the Arduino doesn't reset the LCD, so we
+// can't assume that its in that state when a sketch starts (and the
+// LiquidCrystal constructor is called).
+
+//UART function
+
+char buf[128];
+char tmp[128];
+
+DigoleSerialDisp::DigoleSerialDisp(PinName sda, PinName scl, uint8_t address):
+    _device(sda, scl)
+{
+    _address = (address<<1);
+    _device.frequency(100000);
+    _Comdelay=70;
+}
+
+size_t DigoleSerialDisp::write(const char x)
+{
+    _device.write(_address, (char *) &x, 1);
+    _device.stop();
+    return 1;
+}
+
+size_t DigoleSerialDisp::write(const char *str) 
+{
+    if (str == NULL) return 0;
+    return write(str, strlen(str));
+}
+    
+size_t DigoleSerialDisp::write(const char *buffer, size_t size)
+{
+    int len = 0;
+    if (buffer != NULL) {
+        _device.write(_address, (char *) buffer, size);
+        len = size;
+        delay(7);
+        _device.stop();
+    }
+    return len;
+}
+
+
+size_t DigoleSerialDisp::print(const char c)
+{
+    buf[0] = 'T';
+    buf[1] = 'T';
+    buf[2] = c;
+    buf[3] = 0;
+    write(buf);
+    write(null);
+    return 1;
+}
+
+size_t DigoleSerialDisp::print(const char s[])
+{
+    int len = strlen(s);
+
+    if (s == NULL) return 0;
+
+    buf[0] = 'T';
+    buf[1] = 'T';
+    buf[2] = 0;
+    strncat(buf, s, 125);
+    write(buf);
+    write(null);
+    return len;
+}
+
+size_t DigoleSerialDisp::println(const char s[])
+{
+    return print(s);
+}
+
+/*
+ Print.cpp - Base class that provides print() and println()
+ Copyright (c) 2008 David A. Mellis.  All right reserved.
+ 
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+ 
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+ 
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ 
+ Modified 23 November 2006 by David A. Mellis
+ */
+
+size_t DigoleSerialDisp::print(unsigned char b, int base)
+{
+  return print((unsigned long) b, base);
+}
+
+size_t DigoleSerialDisp::print(int n, int base)
+{
+  return print((long) n, base);
+}
+
+size_t DigoleSerialDisp::print(unsigned int n, int base)
+{
+  return print((unsigned long) n, base);
+}
+
+size_t DigoleSerialDisp::print(long n, int base)
+{
+  if (base == 0) {
+    return write(n);
+  } else if (base == 10) {
+    if (n < 0) {
+      int t = print('-');
+      n = -n;
+      return printNumber(n, 10) + t;
+    }
+    return printNumber(n, 10);
+  } else {
+    return printNumber(n, base);
+  }
+}
+
+size_t DigoleSerialDisp::print(unsigned long n, int base)
+{
+  if (base == 0) return write(n);
+  else return printNumber(n, base);
+}
+
+size_t DigoleSerialDisp::print(double n, int digits)
+{
+  return printFloat(n, digits);
+}
+
+size_t DigoleSerialDisp::println(unsigned char b, int base)
+{
+  size_t n = print(b, base);
+  n += println();
+  return n;
+}
+
+size_t DigoleSerialDisp::println(int num, int base)
+{
+  size_t n = print(num, base);
+  n += println();
+  return n;
+}
+
+size_t DigoleSerialDisp::println(unsigned int num, int base)
+{
+  size_t n = print(num, base);
+  n += println();
+  return n;
+}
+
+size_t DigoleSerialDisp::println(long num, int base)
+{
+  size_t n = print(num, base);
+  n += println();
+  return n;
+}
+
+size_t DigoleSerialDisp::println(unsigned long num, int base)
+{
+  size_t n = print(num, base);
+  n += println();
+  return n;
+}
+
+size_t DigoleSerialDisp::println(double num, int digits)
+{
+  size_t n = print(num, digits);
+  n += println();
+  return n;
+}
+
+size_t DigoleSerialDisp::println(void) 
+{
+    return 1;
+}
+
+// Private Methods /////////////////////////////////////////////////////////////
+
+size_t DigoleSerialDisp::printNumber(unsigned long n, uint8_t base) {
+  char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
+  char *str = &buf[sizeof(buf) - 1];
+
+  *str = '\0';
+
+  // prevent crash if called with base == 1
+  if (base < 2) base = 10;
+
+  do {
+    unsigned long m = n;
+    n /= base;
+    char c = m - base * n;
+    *--str = c < 10 ? c + '0' : c + 'A' - 10;
+  } while(n);
+
+  return write(str);
+}
+
+size_t DigoleSerialDisp::printFloat(double number, uint8_t digits) 
+{ 
+  size_t n = 0;
+  
+  if (isnan(number)) return print("nan");
+  if (isinf(number)) return print("inf");
+  if (number > 4294967040.0) return print ("ovf");  // constant determined empirically
+  if (number <-4294967040.0) return print ("ovf");  // constant determined empirically
+  
+  // Handle negative numbers
+  if (number < 0.0)
+  {
+     n += print('-');
+     number = -number;
+  }
+
+  // Round correctly so that print(1.999, 2) prints as "2.00"
+  double rounding = 0.5;
+  for (uint8_t i=0; i<digits; ++i)
+    rounding /= 10.0;
+  
+  number += rounding;
+
+  // Extract the integer part of the number and print it
+  unsigned long int_part = (unsigned long)number;
+  double remainder = number - (double)int_part;
+  n += print(int_part);
+
+  // Print the decimal point, but only if there are digits beyond
+  if (digits > 0) {
+    n += print("."); 
+  }
+
+  // Extract digits from the remainder one at a time
+  while (digits-- > 0)
+  {
+    remainder *= 10.0;
+    int toPrint = int(remainder);
+    n += print(toPrint);
+    remainder -= toPrint; 
+  } 
+  
+  return n;
+}
+
+/*---------functions for Text and Graphic LCD adapters---------*/
+void DigoleSerialDisp::disableCursor(void) 
+{
+    write("CS");
+    write(null);
+}
+
+void DigoleSerialDisp::enableCursor(void) 
+{
+    write("CS");
+    write(1);
+}
+
+void DigoleSerialDisp::drawStr(uint8_t x, uint8_t y, const char *s) 
+{
+    write("TP");
+    write(x);
+    write(y);
+    write("TT");
+    write(s);
+    write(null);
+}
+
+void DigoleSerialDisp::setPrintPos(uint8_t x, uint8_t y, uint8_t graph) 
+{
+    if (graph == _TEXT_) {
+        write("TP");
+        write(x);
+        write(y);
+    } else {
+        write("GP");
+        write(x);
+        write(y);
+    }
+}
+
+void DigoleSerialDisp::clearScreen(void) 
+{
+    //write(null);
+    write("CL");
+}
+
+void DigoleSerialDisp::setLCDColRow(uint8_t col, uint8_t row) 
+{
+    write("STCR");
+    write(col);
+    write(row);
+    write("\x80\xC0\x94\xD4");
+}
+
+void DigoleSerialDisp::setI2CAddress(uint8_t add) 
+{
+    write("SI2CA");
+    write(add);
+    _address = (add<<1);
+}
+
+void DigoleSerialDisp::displayConfig(uint8_t v) 
+{
+    write("DC");
+    write(v);
+}
+
+void DigoleSerialDisp::preprint(void) 
+{
+    //print("TT");
+}
+
+/*----------Functions for Graphic LCD/OLED adapters only---------*/
+void DigoleSerialDisp::drawBitmap(uint8_t x, uint8_t y, uint8_t w, uint8_t h, const uint8_t *bitmap) {
+    uint8_t i = 0;
+    if ((w & 7) != 0)
+        i = 1;
+    write("DIM");
+    write(x); //x;
+    write(y);
+    write(w);
+    write(h);
+    for (int j = 0; j < h * ((w >> 3) + i); j++) {
+        write( (const char *) (bitmap+j) );
+        delay(1);
+    }
+}
+
+void DigoleSerialDisp::setRot90(void) {
+    write("SD1");
+}
+
+void DigoleSerialDisp::setRot180(void) {
+    write("SD2");
+}
+
+void DigoleSerialDisp::setRot270(void) {
+    write("SD3");
+}
+
+void DigoleSerialDisp::undoRotation(void) {
+    write("SD0");
+}
+
+void DigoleSerialDisp::setRotation(uint8_t d) {
+    write("SD");
+    write(d);
+}
+
+void DigoleSerialDisp::setContrast(uint8_t c) {
+    write("CT");
+    write(c);
+}
+
+void DigoleSerialDisp::drawBox(uint8_t x, uint8_t y, uint8_t w, uint8_t h) {
+    write("FR");
+    write(x);
+    write(y);
+    write(x + w);
+    write(y + h);
+}
+
+void DigoleSerialDisp::drawCircle(uint8_t x, uint8_t y, uint8_t r, uint8_t f) {
+    write("CC");
+    write(x);
+    write(y);
+    write(r);
+    write(f);
+}
+
+void DigoleSerialDisp::drawDisc(uint8_t x, uint8_t y, uint8_t r) {
+    drawCircle(x, y, r, 1);
+}
+
+void DigoleSerialDisp::drawFrame(uint8_t x, uint8_t y, uint8_t w, uint8_t h) {
+    write("DR");
+    write(x);
+    write(y);
+    write(x + w);
+    write(y + h);
+}
+
+void DigoleSerialDisp::drawPixel(uint8_t x, uint8_t y, uint8_t color) {
+    write("DP");
+    write(x);
+    write(y);
+    write(color);
+}
+
+void DigoleSerialDisp::drawLine(uint8_t x, uint8_t y, uint8_t x1, uint8_t y1) {
+    write("LN");
+    write(x);
+    write(y);
+    write(x1);
+    write(y1);
+}
+
+void DigoleSerialDisp::drawLineTo(uint8_t x, uint8_t y) {
+    write("LT");
+    write(x);
+    write(y);
+}
+
+void DigoleSerialDisp::drawHLine(uint8_t x, uint8_t y, uint8_t w) {
+    drawLine(x, y, x + w, y);
+}
+
+void DigoleSerialDisp::drawVLine(uint8_t x, uint8_t y, uint8_t h) {
+    drawLine(x, y, x, y + h);
+}
+
+void DigoleSerialDisp::nextTextLine(void) {
+    write(null);
+    write("TRT");
+}
+
+void DigoleSerialDisp::setFont(uint8_t font) {
+    write("SF");
+    write(font);
+}
+
+void DigoleSerialDisp::setColor(uint8_t color) {
+    write("SC");
+    write(color);
+}
+
+void DigoleSerialDisp::backLightOn(void) {
+    write("BL");
+    write(1);
+}
+
+void DigoleSerialDisp::backLightOff(void) {
+    write("BL");
+    write(null);
+}
+
+void DigoleSerialDisp::directCommand(uint8_t d) {
+    write("MCD");
+    write(d);
+}
+
+void DigoleSerialDisp::directData(uint8_t d) {
+    write("MDT");
+    write(d);
+}
+
+void DigoleSerialDisp::moveArea(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1, char xoffset, char yoffset) {
+    write("MA");
+    write(x0);
+    write(y0);
+    write(x1);
+    write(y1);
+    write(xoffset);
+    write(yoffset);
+}
+
+
+void DigoleSerialDisp::displayStartScreen(uint8_t m) {
+    write("DSS");
+    write(m);
+} //display start screen
+
+
+void DigoleSerialDisp::setMode(uint8_t m) {
+    write("DM");
+    write(m);
+} //set display mode
+
+
+void DigoleSerialDisp::setTextPosBack(void) {
+    write("ETB");
+} //set text position back to previous, only one back allowed
+
+
+void DigoleSerialDisp::setTextPosOffset(char xoffset, char yoffset) {
+    write("ETO");
+    write(xoffset);
+    write(yoffset);
+}
+
+
+void DigoleSerialDisp::setTextPosAbs(uint8_t x, uint8_t y) {
+    write("ETP");
+    write(x);
+    write(y);
+}
+
+
+void DigoleSerialDisp::setLinePattern(uint8_t pattern) {
+    write("SLP");
+    write(pattern);
+}
+
+
+void DigoleSerialDisp::setLCDChip(uint8_t chip) {      //only for universal LCD adapter
+    write("SLCD");
+    write(chip);
+}
+
+
+void DigoleSerialDisp::uploadStartScreen(int lon, const unsigned char *data) 
+{
+    int j;
+    uint8_t c;
+    write("SSS");
+    write((uint8_t) (lon % 256));
+    write((uint8_t) (lon / 256));
+    for (j = 0; j < lon;j++) {
+        if((j%32)==0)
+            delay(10);
+        delay(_Comdelay);
+        c = data[j];
+        write(c);
+    }
+}
+
+
+void DigoleSerialDisp::uploadUserFont(int lon, const unsigned char *data, uint8_t sect) {
+    uint8_t c;
+    write("SUF");
+    write(sect);
+    write((uint8_t) (lon % 256));
+    write((uint8_t) (lon / 256));
+    for (int j = 0; j < lon; j++) {
+        if((j%32)==0)
+            delay(10);
+        delay(_Comdelay);
+        c = data[j];
+        write(c);
+    }
+}
+
+void DigoleSerialDisp::digitalOutput(uint8_t x) 
+{
+    write("DOUT");
+    write(x);
+}
\ No newline at end of file
diff -r 000000000000 -r 535e018f97b9 DigoleSerialDisplay/DigoleSerialDisp.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DigoleSerialDisplay/DigoleSerialDisp.h	Sat Jun 22 09:33:42 2013 +0000
@@ -0,0 +1,354 @@
+/** Digole Serial Display library, I2C
+ *
+ * @Author: Digole Digital Solutions : www.digole.com ported from Arduino to mbed by Michael Shimniok www.bot-thoughts.com
+ */
+#ifndef DigoleSerialDisp_h
+#define DigoleSerialDisp_h
+ 
+#include "mbed.h"
+#include <inttypes.h>
+ 
+#define DEC 10
+#define HEX 16
+#define OCT 8
+#define BIN 2
+ 
+#define delay(x) wait_ms(x)
+ 
+// Communication set up command
+// Text function command
+// Graph function command
+ 
+#define Serial_UART 0;
+#define Serial_I2C 1;
+#define Serial_SPI 2;
+#define _TEXT_ 0
+#define _GRAPH_ 1
+ 
+/** Digole Serial LCD/OLED Library
+ * www.digole.com/index.php?productID=535
+ *
+ * Includes Arduino Print class member functions
+ */
+class DigoleSerialDisp {
+public:
+ 
+    /** Create a new Digole Serial Display interface
+     *
+     * @param sda is the pin for I2C SDA
+     * @param scl is the pin for I2C SCL
+     * @param address is the 7-bit address (default is 0x27 for the device)
+     */
+    DigoleSerialDisp(PinName sda, PinName scl, uint8_t address=0x27);
+ 
+ 
+    /** Carryover from Arduino library, not needed
+     */
+    void begin(void) { } // nothing to do here
+ 
+ 
+    /** Write out a raw character
+     * @param x is the character to write
+     * @returns 1
+     */
+    size_t write(const char x);
+ 
+ 
+    /** Write out raw data from a buffer
+     * @param buffer is the char array to write
+     * @param size is the the number of bytes to write
+     * @returns size
+     */
+    size_t write(const char *buffer, size_t size);
+ 
+ 
+    /** Write out raw string
+     * @param str is the string to write
+     * @returns number of bytes written
+     */
+    size_t write(const char *str);
+   
+   
+    /** Prints a char to the display in a single I2C transmission using "TTb\0"
+     *
+     * @param c is the character to print
+     * @returns 1
+     */
+    size_t print(const char c);
+ 
+ 
+    /** Prints a string of data to the display in a single I2C transmission using "TTbbb...\0"
+     *
+     * @param s is the null-terminated char array to print
+     * @returns length of s 
+     */
+    size_t print(const char s[]);
+ 
+ 
+    /** Print out an unsigned char as a number
+     * @param u is the integer to print
+     * @param base is the base to print, either DEC (default), HEX, BIN
+     * @returns number of chars written
+     */
+    size_t print(unsigned char u, int base = DEC);
+ 
+ 
+    /** Print out an integer
+     * @param i is the integer to print
+     * @param base is the base to print, either DEC (default), HEX, BIN
+     * @returns number of chars written
+     */
+    size_t print(int i, int base = DEC);
+ 
+ 
+    /** Print out an unsigned integer
+     * @param u is the integer to print
+     * @param base is the base to print, either DEC (default), HEX, BIN
+     * @returns number of chars written
+     */
+    size_t print(unsigned int u, int base = DEC);
+    
+ 
+    /** Print out a long as a number
+     * @param l is the integer to print
+     * @param base is the base to print, either DEC (default), HEX, BIN
+     * @returns number of chars written
+     */
+    size_t print(long l, int base = DEC);
+    
+ 
+    /** Print out an unsigned long
+     * @param l is the integer to print
+     * @param base is the base to print, either DEC (default), HEX, BIN
+     * @returns number of chars written
+     */
+    size_t print(unsigned long l, int base = DEC);
+ 
+ 
+    /** Print out a double
+     * @param f is the integer to print
+     * @param digits is the number of digits after the decimal
+     */
+    size_t print(double f, int digits = 2);
+ 
+ 
+    /** Prints a string of data to the display in a single I2C transmission using "TTbbb...\0"
+     *
+     * @param s is the null-terminated char array to print
+     * @returns length of s 
+     */
+    size_t println(const char s[]);
+ 
+ 
+    /** Prints a char the display in a single I2C transmission using "TTb\0"
+     *
+     * @param c is the character to print
+     * @returns 1
+     */
+    size_t println(char c);
+ 
+ 
+    /** Prints an unsigned char as a number
+     *
+     * @param u is the unsigned char number
+     * @returns 1
+     */
+    size_t println(unsigned char u, int base = DEC);
+ 
+ 
+    /** Print out an integer
+     * @param i is the integer to print
+     * @param base is the base to print, either DEC (default), HEX, BIN
+     * @returns number of chars written
+     */
+    size_t println(int i, int base = DEC);
+ 
+ 
+    /** Print out an unsigned char as a number
+     * @param u is the integer to print
+     * @param base is the base to print, either DEC (default), HEX, BIN
+     * @returns number of chars written
+     */
+    size_t println(unsigned int u, int base = DEC);
+ 
+ 
+    /** Print out a long as a number
+     * @param l is the integer to print
+     * @param base is the base to print, either DEC (default), HEX, BIN
+     * @returns number of chars written
+     */
+    size_t println(long l, int base = DEC);
+ 
+ 
+    /** Print out an unsigned long
+     * @param l is the integer to print
+     * @param base is the base to print, either DEC (default), HEX, BIN
+     * @returns number of chars written
+     */
+    size_t println(unsigned long l, int base = DEC);
+ 
+ 
+    /** Print out a double
+     * @param f is the integer to print
+     * @param digits is the number of digits after the decimal
+     * @returns number of chars written
+     */
+    size_t println(double f, int digits = 2);
+ 
+ 
+    /** prints, well, nothing in this case, but pretend we printed a newline
+     * @returns 1
+     */
+    size_t println(void);
+   
+ 
+    /*---------functions for Text and Graphic LCD adapters---------*/    
+ 
+    /** Turns off the cursor */
+    void disableCursor(void);
+    
+    /** Turns on the cursor */
+    void enableCursor(void);
+    
+    /** Displays a string at specified coordinates
+     * @param x is the x coordinate to display the string
+     * @param y is the y coordinate to display the string
+     * @param s is the string to display
+     */
+    void drawStr(uint8_t x, uint8_t y, const char *s);
+    
+    /** Sets the print position for graphics or text
+     * @param x is the x coordinate to display the string
+     * @param y is the y coordinate to display the string
+     * @param graph if set to _TEXT_ affects subsequent text position, otherwise, affects graphics position
+     */
+    void setPrintPos(uint8_t x, uint8_t y, uint8_t graph = _TEXT_);
+    
+    /** Clears the display screen */
+    void clearScreen(void);
+    
+    /** Configure your LCD if other than 1602 and the chip is other than KS0066U/F / HD44780 
+     * @param col is the number of columns
+     * @param row is the number of rows
+     */
+    void setLCDColRow(uint8_t col, uint8_t row);
+    
+    /** Sets a new I2C address for the display (default is 0x27), the adapter will store the new address in memory
+     * @param address is the the new address 
+     */
+    void setI2CAddress(uint8_t add);
+    
+    /** Display Config on/off, the factory default set is on, 
+     * so, when the module is powered up, it will display 
+     * current communication mode on LCD, after you 
+     * design finished, you can turn it off
+     * @param v is the 1 is on, 0 is off
+     */
+    void displayConfig(uint8_t v);
+    
+    /** Holdover from Arduino library; not needed */
+    void preprint(void);
+    
+    /*----------Functions for Graphic LCD/OLED adapters only---------*/
+    //the functions in this section compatible with u8glib
+    void drawBitmap(uint8_t x, uint8_t y, uint8_t w, uint8_t h, const uint8_t *bitmap);
+    void setRot90(void);
+    void setRot180(void);
+    void setRot270(void);
+    void undoRotation(void);
+    void setRotation(uint8_t);
+    void setContrast(uint8_t);
+    void drawBox(uint8_t x, uint8_t y, uint8_t w, uint8_t h);
+    void drawCircle(uint8_t x, uint8_t y, uint8_t r, uint8_t = 0);
+    void drawDisc(uint8_t x, uint8_t y, uint8_t r);
+    void drawFrame(uint8_t x, uint8_t y, uint8_t w, uint8_t h);
+    void drawPixel(uint8_t x, uint8_t y, uint8_t = 1);
+    void drawLine(uint8_t x, uint8_t y, uint8_t x1, uint8_t y1);
+    void drawLineTo(uint8_t x, uint8_t y);
+    void drawHLine(uint8_t x, uint8_t y, uint8_t w);
+    void drawVLine(uint8_t x, uint8_t y, uint8_t h);
+    //-------------------------------
+    //special functions for our adapters
+    
+    /** Sets the font
+     *
+     * @parameter font - available fonts: 6,10,18,51,120,123, user font 200-203
+     */
+    void setFont(uint8_t font);
+    
+    /** go to next text line, depending on the font size */
+    void nextTextLine(void);
+    
+    /** set color for graphic function */ 
+    void setColor(uint8_t); 
+    
+    /** Turn on back light */
+    void backLightOn(void); 
+    
+    /** Turn off back light */
+    void backLightOff(void); 
+    
+    /** send command to LCD drectly 
+     * @param d - command
+     */
+    void directCommand(uint8_t d); 
+    
+    /** send data to LCD drectly
+     * @param d is the data
+     */
+    void directData(uint8_t d); 
+    
+    /** Move rectangle area on screen to another place
+     * @param x0, y1 is the top left of the area to move
+     * @param x1, y1 is the bottom right of the area to move
+     * @param xoffset, yoffset is the the distance to move
+     */
+    void moveArea(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1, char xoffset, char yoffset);
+ 
+    /** Display startup screen */
+    void displayStartScreen(uint8_t m);
+    
+    /** Set display mode */
+    void setMode(uint8_t m);
+ 
+    /** set text position back to previous, only one back allowed */
+    void setTextPosBack(void);    
+    
+    void setTextPosOffset(char xoffset, char yoffset);
+    void setTextPosAbs(uint8_t x, uint8_t y);
+    void setLinePattern(uint8_t pattern);
+    /** Only for universal serial adapter */
+    void setLCDChip(uint8_t chip);
+ 
+ 
+    /** Set Start Screen, 1st B is the lower byte of data length. 
+     * Convert images to C array here: <a href="http://www.digole.com/tools/PicturetoC_Hex_converter.php">http://www.digole.com/tools/PicturetoC_Hex_converter.php</a>
+     * @param lon is the length of data
+     * @param data is the binary data
+     */
+    void uploadStartScreen(int lon, const unsigned char *data); //upload start screen
+    
+    /** Upload a user font
+     * @param lon is the length of data
+     * @param data is the user font data
+     * @param sect is the section of memory you want to upload to
+     */
+    void uploadUserFont(int lon, const unsigned char *data, uint8_t sect); //upload user font
+ 
+    /** Send a Byte to output head on board
+     * @param x is the byte to output
+     */
+    void digitalOutput(uint8_t x);
+ 
+private:
+    I2C _device;
+    uint8_t _address;
+    uint8_t _Comdelay;
+ 
+    size_t printNumber(unsigned long n, uint8_t base);
+    size_t printFloat(double number, uint8_t digits);
+};
+ 
+#endif
+ 
+    
\ No newline at end of file
diff -r 000000000000 -r 535e018f97b9 main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Sat Jun 22 09:33:42 2013 +0000
@@ -0,0 +1,21 @@
+#include "mbed.h"
+#include "DigoleSerialDisp.h"
+//Digole Serial Display FRDM-KL-25Z 
+DigoleSerialDisp myOLED(PTE0, PTE1, 0x27);
+DigitalOut myled(LED1);
+
+int main() {
+    myOLED.clearScreen();
+    myOLED.drawFrame(0,0,127,63);
+    myOLED.setPrintPos(1,1,_TEXT_);
+    myOLED.println("Hello");
+    myOLED.setPrintPos(1,2,_TEXT_);
+    myOLED.println("World");
+    
+    while(1) {
+        wait(1);
+        myled = 1;
+        wait(1);
+        myled = 0;
+    }
+}
diff -r 000000000000 -r 535e018f97b9 mbed.bld
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Sat Jun 22 09:33:42 2013 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed/builds/5e5da4a5990b
\ No newline at end of file