Dependents:   Display bigthingRec bigthingRecfinal

Files at this revision

API Documentation at this revision

Comitter:
kagelump
Date:
Mon Jun 18 16:46:41 2012 +0000
Commit message:

Changed in this revision

KS0108.cpp Show annotated file Show diff for this revision Revisions of this file
KS0108.h Show annotated file Show diff for this revision Revisions of this file
MyPhone_20.h Show annotated file Show diff for this revision Revisions of this file
MyPhone_40.h Show annotated file Show diff for this revision Revisions of this file
SystemFont5x7.h Show annotated file Show diff for this revision Revisions of this file
diff -r 000000000000 -r 14a7c22dfbe8 KS0108.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/KS0108.cpp	Mon Jun 18 16:46:41 2012 +0000
@@ -0,0 +1,843 @@
+#include "KS0108.h"     
+
+
+KS0108::KS0108 (PinName _RST,PinName _DI, PinName _RW, PinName _E, PinName _CS2, PinName _CS1, PinName DB0, PinName DB1, PinName DB2, PinName DB3, PinName DB4, PinName DB5, PinName DB6, PinName DB7)
+    : DB(DB0,DB1,DB2,DB3,DB4,DB5,DB6,DB7),RST (_RST),DI(_DI), RW(_RW), E(_E), CS2(_CS2), CS1(_CS1) {
+   
+    DB.output();      
+    CS1.output(); CS2.output();    
+    RST.write(0);
+    wait_us(10);  
+    RST.write(1);                         //reset screen
+    E.write(0);                       
+    ClearScreen();                      //clear display
+    WriteInstruction(LCD_ON, BOTH);     //turn on lcd  
+    Inverted = 0;     
+}
+
+
+
+void  KS0108::WriteInstruction(unsigned int Command,unsigned int side){
+    E.write(0); 
+    DI.write(0);
+    RW.write(0);
+        
+    SelectSide(side);   //select controller
+
+    wait(0.0000003);     //wait 300ns
+    E.write(1);
+    DB.output();
+    DB.write(Command);        
+    wait(0.0000001);
+    E.write(0);
+}
+
+
+void  KS0108::WriteData(unsigned int data,unsigned char side){
+    E.write(0); 
+    DI.write(1);
+    RW.write(0);
+    
+    SelectSide(side);
+
+    wait(0.0000003); // 300ns
+    E = 1;
+    DB.output();
+    DB.write(data);     
+    wait(0.0000001);
+    E = 0;
+}
+
+void KS0108::WriteData(unsigned int data) {
+    unsigned int displayData, yOffset, chip;
+    
+    if(Coord.x >= SCREEN_WIDTH)
+        return;
+     chip = Coord.x/CHIP_WIDTH; 
+     wait(0.000000450); // 300ns     
+
+     if(Coord.x % CHIP_WIDTH == 0 && chip > 0){         
+     GotoXY(Coord.x, Coord.y);
+     }
+
+    DI.write(1);                    // D/I = 1
+    RW.write(0);                      // R/W = 0    
+    DB.output();                    // data port is output
+    
+    yOffset = Coord.y%8;
+
+    if(yOffset != 0) {                 // first page
+
+    displayData = ReadData();
+
+    DI.write(1);                            // D/I = 1
+    RW.write(0);                              // R/W = 0    
+    SelectSide(chip);    
+    DB.output();
+                                            // data port is output             
+    displayData |= data << yOffset;
+    if(Inverted)    displayData = ~displayData;
+    DB.write(displayData);                     // write data
+    wait(0.0000003);                         // 300ns
+    E.write(1);
+    wait(0.0000001);
+    E.write(0);
+        
+                                    // second page
+    GotoXY(Coord.x, Coord.y+8);
+        
+    displayData = ReadData();
+
+    DI.write(1);                            // D/I = 1
+    RW.write(0);                              // R/W = 0    
+    SelectSide(chip);
+
+    DB.output();                // data port is output
+        
+    displayData |= data >> (8-yOffset);
+    
+        if(Inverted)
+            displayData = ~displayData;
+            DB.write(displayData);        // write data
+           
+            wait(0.0000003);             // 300ns
+            E.write(1);
+            wait(0.0000001);
+            E.write(0);
+        
+        GotoXY(Coord.x+1, Coord.y-8);
+    }else    {
+
+        // just this code gets executed if the write is on a single page
+        if(Inverted)
+            data = ~data;      
+        wait(0.0000003);                 // 300nsEN_DELAY();
+        DB.write(data);                    // write data
+        wait(0.0000003);                 // 300ns
+           E = 1;
+           wait(0.0000001);
+        E = 0;
+        Coord.x++; 
+    }
+}
+
+
+void KS0108::WriteDataColPag(unsigned int page, unsigned int col,  unsigned int data){
+    
+    SelectSide(NONE);  
+    col     = col%SCREEN_WIDTH;
+    page    = page%8;
+
+    if(col<(SCREEN_WIDTH/2)){
+    SelectSide(LEFT);           
+    WriteInstruction(LCD_SET_PAGE|page,LEFT);     
+    WriteInstruction(LCD_SET_ADD|col,LEFT);          //set page and column position
+    WriteData(data,LEFT);                            //output data to D0-D7
+    }else{
+    
+    SelectSide(RIGHT);
+    col -= (SCREEN_WIDTH/2);     
+    WriteInstruction(LCD_SET_PAGE|page,RIGHT);     
+    WriteInstruction(LCD_SET_ADD|col,RIGHT);        //set page and column position
+    WriteData(data,RIGHT);                          //output data to D0-D7
+    }    
+                           
+    SelectSide(NONE);
+}
+
+
+
+unsigned int KS0108::ReadData(){
+   unsigned int data;
+   DB.input();
+
+   DI.write(1);     
+   RW.write(1);
+
+   E.write(1);
+   wait(0.00000045);
+      
+   data = DB.read();
+   wait(0.0000001);
+   E.write(0);   
+   DB.output();
+   
+   return data;     
+}
+
+unsigned int KS0108::ReadStatus(){
+   unsigned int status;
+   DB.input();
+ 
+   DI.write(0);
+   
+   RW.write(1);
+   E.write(1);
+   wait(0.00000045);
+      
+   status = DB.read();
+   E.write(0);
+   wait(0.0000001);
+   DB.output();
+   
+   return status;     
+}                    
+
+
+
+void KS0108::SelectSide(unsigned char side){
+    if(side==LEFT)
+        {CS1.write(1);CS2.write(0);}
+    else if(side==RIGHT)
+        {CS1.write(0);CS2.write(1);}
+    else if (side==BOTH)
+        {CS1.write(1);CS2.write(1);}
+    else if (side==NONE)
+        {CS1.write(0);CS2.write(0);}
+}
+
+
+void KS0108::ClearScreen(){
+     for (int col=0;col<128;col++) {
+        for (int page=0;page<8;page++)
+        {
+            WriteDataColPag(page,col,WHITE);
+        }
+    }
+}     
+
+
+void KS0108::TurnOn(){
+    WriteInstruction(LCD_ON,BOTH);
+}
+
+
+void KS0108::TurnOff(){
+    WriteInstruction(LCD_OFF,BOTH);
+}
+
+
+/*******************************************************************************************/      
+
+ 
+void KS0108::SetPixel(unsigned int x,  unsigned int y,  unsigned int color){    
+  
+  unsigned int position;
+   
+  SelectSide(NONE);
+  WriteInstruction(LCD_SET_ADD,NONE);    
+  
+  if(x>=64){           
+  WriteInstruction(LCD_SET_PAGE|(y/8),RIGHT);
+  WriteInstruction(LCD_SET_ADD|x,RIGHT);
+  position = ReadData();                            //dummy read 
+  position = ReadData();                            //actual read 
+  WriteInstruction(LCD_SET_ADD|x,RIGHT);
+  if(color==WHITE)                                
+  WriteData(position&(~(1<<(y%8))),RIGHT);         // draw a white pixel
+  else                                            
+  WriteData(position|(1<<(y%8)),RIGHT);
+  wait_us(450);
+  }else{ 
+  WriteInstruction(LCD_SET_PAGE|(y/8),LEFT);
+  WriteInstruction(LCD_SET_ADD|x,LEFT);  
+  position = ReadData();                            //dummy read 
+  position = ReadData();                            //actual read 
+  WriteInstruction(LCD_SET_ADD|x,LEFT);
+  if(color==WHITE)                                
+  WriteData(position&(~(1<<(y%8))),LEFT);              
+  else                                            
+  WriteData(position|(1<<(y%8)),LEFT);
+  
+  wait_us(450);
+
+  }
+
+}       
+
+
+
+void KS0108::FullRectangle(unsigned int Xaxis1, unsigned int Yaxis1, unsigned int Xaxis2 ,unsigned int Yaxis2,unsigned int color){
+           
+    for(unsigned int i=Xaxis1;i<=Xaxis2;i++){
+        for(unsigned int j=Yaxis1;j<=Yaxis2;j++){
+            SetPixel(i,j,color);
+        } 
+    }   
+}
+
+void KS0108::ReverseFullRectangle(unsigned int Xaxis1, unsigned int Yaxis1, unsigned int Xaxis2 ,unsigned int Yaxis2,unsigned int color){
+           
+    for(unsigned int i=Xaxis2;i<=Xaxis1;i--){
+        for(unsigned int j=Yaxis2;j<=Yaxis1;j--){
+            SetPixel(i,j,color);
+        } 
+    }   
+}  
+
+
+void KS0108::EmptyRectangle(unsigned int Xaxis1,unsigned int Yaxis1, unsigned int Xaxis2,unsigned int Yaxis2,unsigned int color){
+      unsigned int CurrentValue;
+
+    /* Draw the two horizontal lines */
+      for (CurrentValue = 0; CurrentValue < Xaxis2 - Xaxis1+ 1; CurrentValue++) 
+      {
+        SetPixel(Xaxis1 + CurrentValue, Yaxis1,color);
+        SetPixel(Xaxis1 + CurrentValue, Yaxis2,color);
+    }
+      
+      /* draw the two vertical lines */
+      for (CurrentValue = 0; CurrentValue < Yaxis2 - Yaxis1 + 1; CurrentValue++)    
+      {
+        SetPixel(Xaxis1, Yaxis1 + CurrentValue,color);
+        SetPixel(Xaxis2, Yaxis1 + CurrentValue,color);
+    }
+}
+
+
+void KS0108::RoundRectangle(unsigned int x, unsigned int y, unsigned int width, unsigned int height, unsigned int radius, unsigned int color) {
+      int tSwitch, x1 = 0, y1 = radius;
+      tSwitch = 3 - 2 * radius;
+    
+    while (x1 <= y1) {
+        SetPixel(x+radius - x1, y+radius - y1, color);
+        SetPixel(x+radius - y1, y+radius - x1, color);
+
+        SetPixel(x+width-radius + x1, y+radius - y1, color);
+        SetPixel(x+width-radius + y1, y+radius - x1, color);
+        
+        SetPixel(x+width-radius + x1, y+height-radius + y1, color);
+        SetPixel(x+width-radius + y1, y+height-radius + x1, color);
+
+        SetPixel(x+radius - x1, y+height-radius + y1, color);
+        SetPixel(x+radius - y1, y+height-radius + x1, color);
+
+        if (tSwitch < 0) {
+            tSwitch += (4 * x1 + 6);
+        } else {
+            tSwitch += (4 * (x1 - y1) + 10);
+            y1--;
+        }
+        x1++;
+    }
+          
+    HLineShort(x+radius,y, width-(2*radius), color);                // top
+    HLineShort(x+radius,y+height, width-(2*radius),  color);        // bottom
+    VLineShort(x,y+radius,height-(2*radius), color);                // left
+    VLineShort(x+width, y+radius,height-(2*radius),  color);        // right
+}
+
+
+void KS0108::HLine(unsigned int Xaxis1, unsigned int Xaxis2 ,unsigned int Yaxis,unsigned int color){
+    FullRectangle(Xaxis1,Yaxis,Xaxis2,Yaxis,color);
+
+}
+
+
+void KS0108::HLineShort(unsigned int Xaxis, unsigned int Yaxis,unsigned int width ,unsigned int color){
+    FullRectangle(Xaxis,Yaxis,Xaxis+width,Yaxis,color);
+
+} 
+
+
+void KS0108::VLine(unsigned int Xaxis, unsigned int Yaxis1 ,unsigned int Yaxis2,unsigned int color){
+    FullRectangle(Xaxis,Yaxis1,Xaxis,Yaxis2,color);    
+}
+
+
+void KS0108::VLineShort(unsigned int Xaxis,unsigned int Yaxis, unsigned int height ,unsigned int color){
+    FullRectangle(Xaxis,Yaxis,Xaxis,Yaxis+height,color);
+
+}
+
+
+void KS0108::DegreeLine(unsigned int x, int y,unsigned int degree,unsigned int inner_radius,unsigned int outer_radius, unsigned int color){
+  int fx,fy,tx,ty;
+  fx = x + dfloor(inner_radius * sin(degree * 3.14 / 180));
+  fy = y - dfloor(inner_radius * cos(degree * 3.14 / 180));
+  tx = x + dfloor(outer_radius * sin(degree * 3.14 / 180));
+  ty = y - dfloor(outer_radius * cos(degree * 3.14 / 180));
+  SlantyLine(fx,fy,tx,ty,color);
+}
+
+
+double KS0108::dfloor( double value ) {
+  
+  if (value < 0.0)
+    return ceil( value );
+  else
+    return floor( value );
+    
+}
+
+
+void KS0108::SlantyLine(unsigned int lX1, unsigned int lY1, unsigned int lX2,unsigned int lY2,unsigned int color){
+    long lError, lDeltaX, lDeltaY, lYStep, bSteep;       
+    
+    // A steep line has a bigger ordinate.
+    
+    if(((lY2 > lY1) ? (lY2 - lY1) : (lY1 - lY2)) > ((lX2 > lX1) ? (lX2 - lX1) : (lX1 - lX2))){
+        bSteep = 1;
+    }else {
+        bSteep = 0;
+    }
+        
+    // If line is steep, swap the X and Y coordinates.
+    if(bSteep){
+        lError = lX1;
+        lX1 = lY1;
+        lY1 = lError;
+        lError = lX2;
+        lX2 = lY2;
+        lY2 = lError;
+    }
+
+   
+    // If the starting X coordinate is larger than the ending X coordinate,
+    // swap coordinates.
+    if(lX1 > lX2){
+        lError = lX1;
+        lX1 = lX2;
+        lX2 = lError;
+        lError = lY1;
+        lY1 = lY2;
+        lY2 = lError;
+    }
+        
+    // Compute the difference between the start and end coordinates.      
+    lDeltaX = lX2 - lX1;
+    lDeltaY = (lY2 > lY1) ? (lY2 - lY1) : (lY1 - lY2);
+                                                                   
+    lError = -lDeltaX / 2;          // Initialize the error term to negative half the X delta.
+     
+    if(lY1 < lY2){                   // Determine the direction to step in the Y axis when required.
+        lYStep = 1;
+    }else{
+        lYStep = -1;
+    }
+        
+    for(; lX1 <= lX2; lX1++){    // Loop through all the points along the X axis of the line.
+        
+        // See if this is a steep line.
+        
+        if(bSteep){
+            
+            // Plot this point of the line, swapping the X and Y coordinates.
+            
+            SetPixel(lY1, lX1,color);
+        }
+        else {           // Plot this point of the line, using the coordinates as is.            
+            SetPixel(lX1, lY1,color);
+        }                     
+        
+        // Increment the error term by the Y delta.
+        
+        lError += lDeltaY; 
+                    
+        if(lError > 0){                // See if the error term is now greater than zero.
+                     
+            lY1 += lYStep;            // Take a step in the Y axis.
+                                                                       
+            lError -= lDeltaX;         // Decrement the error term by the X delta.
+        }
+    }
+}
+
+
+
+void KS0108::Line(unsigned int x1, unsigned int  y1, unsigned int  x2, unsigned int  y2, unsigned int color){
+unsigned int  deltax, deltay, x,y, steep;
+int lerror, ystep;
+
+    steep = absDiff(y1,y2) > absDiff(x1,x2);   //check slope
+
+    if ( steep ){
+        swap(x1, y1);
+        swap(x2, y2);
+    }
+
+    if (x1 > x2){
+        swap(x1, x2);
+        swap(y1, y2);
+    }
+
+    deltax = x2 - x1;
+    deltay = absDiff(y2,y1);  
+    lerror = deltax / 2;
+    y = y1;
+    if(y1 < y2) ystep = 1;  else ystep = -1;
+
+    for(x = x1; x <= x2; x++){
+        if (steep) SetPixel(y,x, color); else SetPixel(x,y, color);
+           lerror -= deltay;
+        if (lerror < 0){
+            y = y + ystep;
+            lerror += deltax;
+        }
+    }
+}
+
+
+void KS0108::EmptyCircle(unsigned int CenterX, unsigned int CenterY, unsigned int Radius,unsigned int color){
+  unsigned int y=0, x=0, d = 0;
+  int part; 
+  d = CenterY - CenterX;
+  y = Radius;
+  part = 3 - 2 * Radius;
+
+  while (x <= y) { 
+    SetPixel(CenterX + x, CenterY + y,color);  
+    SetPixel(CenterX + x, CenterY - y,color);
+    SetPixel(CenterX - x, CenterY + y,color);    
+    SetPixel(CenterX - x, CenterY - y,color);
+    SetPixel(CenterY + y - d, CenterY + x,color); 
+    SetPixel(CenterY + y - d, CenterY - x,color);
+    SetPixel(CenterY - y - d, CenterY + x,color);
+    SetPixel(CenterY - y - d, CenterY - x,color); 
+
+    if (part < 0) part += (4 * x + 6);
+    else {
+      part += (4 * (x - y) + 10);
+      y--;
+    }
+    x++;
+  }
+
+}  
+
+ 
+void KS0108::FullCircle(unsigned int CenterX, unsigned int CenterY, unsigned int Radius,unsigned int color){  
+
+int f = 1 - Radius;
+int ddF_x = 1;
+int ddF_y = 2 * Radius;             //changed sign of -2
+unsigned int x = 0;
+unsigned int y = Radius;      
+    
+     //Fill in the center between the two halves
+     
+    Line(CenterX, CenterY-Radius, CenterX, CenterY+Radius, color);
+ 
+    while(x < y){
+        if(f >= 0)
+        {
+            y--;
+            ddF_y += 2;
+            f += ddF_y;
+        }
+        x++;
+        ddF_x += 2;
+        f += ddF_x;    
+
+        /*
+         * Now draw vertical lines between the points on the circle rather than
+         * draw the points of the circle. This draws lines between the 
+         * perimeter points on the upper and lower quadrants of the 2 halves of the circle.
+         */
+
+        Line(CenterX+x, CenterY+y, CenterX+x, CenterY-y, color);
+        Line(CenterX-x, CenterY+y, CenterX-x, CenterY-y, color);
+        Line(CenterX+y, CenterY+x, y+CenterX, CenterY-x, color);
+        Line(CenterX-y, CenterY+x, CenterX-y, CenterY-x, color);
+      }
+}                 
+
+
+
+void KS0108::PlotEllipse(long CX, long  CY, long XRadius,long YRadius, int color) {
+
+
+  long X, Y;
+  long XChange, YChange;
+  long EllipseError;
+  long TwoASquare,TwoBSquare;
+  long StoppingX, StoppingY;
+  TwoASquare = 2*XRadius*XRadius;
+  TwoBSquare = 2*YRadius*YRadius;
+  X = XRadius;
+  Y = 0;
+  XChange = YRadius*YRadius*(1-2*XRadius);
+  YChange = XRadius*XRadius;
+  EllipseError = 0;
+  StoppingX = TwoBSquare*XRadius;
+  StoppingY = 0;
+
+  while ( StoppingX >=StoppingY )                 //first set of points,y'>-1
+  {
+    Plot4EllipsePoints(CX,CY,X,Y,color);
+    Y++;
+    StoppingY=StoppingY+ TwoASquare;
+    EllipseError = EllipseError+ YChange;
+    YChange=YChange+TwoASquare;
+    if ((2*EllipseError + XChange) > 0 ) {
+      X--;
+      StoppingX=StoppingX- TwoBSquare;
+      EllipseError=EllipseError+ XChange;
+      XChange=XChange+TwoBSquare;
+    }
+  }
+
+  Y = YRadius;
+  X = 0;
+  YChange = XRadius*XRadius*(1-2*YRadius);
+  XChange = YRadius*YRadius;
+  EllipseError = 0;
+  StoppingY = TwoASquare*YRadius;
+  StoppingX = 0;
+
+  while ( StoppingY >=StoppingX )                 //{2nd set of points, y'< -1}
+  {
+    Plot4EllipsePoints(CX,CY,X,Y,color);
+    X++;
+    StoppingX=StoppingX + TwoBSquare;
+    EllipseError=EllipseError+ XChange;
+    XChange=XChange+TwoBSquare;
+    if ((2*EllipseError + YChange) > 0 ) {
+      Y--;
+      StoppingY=StoppingY- TwoASquare;
+      EllipseError=EllipseError+ YChange;
+      YChange=YChange+TwoASquare;
+    }
+  }
+} 
+
+
+
+void KS0108::Plot4EllipsePoints(long CX,long  CY, long X, long Y, int color){
+  SetPixel(CX+X, CY+Y, color); //{point in quadrant 1}
+  SetPixel(CX-X, CY+Y, color); //{point in quadrant 2}
+  SetPixel(CX-X, CY-Y, color); //{point in quadrant 3}
+  SetPixel(CX+X, CY-Y, color); //{point in quadrant 4}
+}                                                        
+
+
+void KS0108::RightTriangle ( int topx, int topy, int rightx, int righty) {
+
+    //draw rectangle one line at a time
+    Line( topx,topy, rightx,righty,BLACK );        //draw hypotenuse
+    Line ( topx,righty,topx,topy,BLACK);         //draw perpendicular
+    Line (topx,righty, rightx,righty,BLACK);      // draw base
+    
+}
+
+void KS0108::Triangle ( int topx, int topy, int rightx, int righty) {
+    int base =0;
+    base = 2* rightx-topx;
+    //draw rectangle one line at a time
+    Line( topx,topy, rightx,righty,BLACK );                //draw hypotenuse
+    Line ( topx,righty,topx,topy,BLACK);                     //draw perpendicular
+    Line(topx-base/2,righty, rightx,righty,BLACK);         // draw base
+    Line(topx-base/2, righty, topx,topy,BLACK);            // draw hypotenuse
+    
+}
+
+
+
+
+/***********************************************************************************/
+
+
+void KS0108::FullScreenBMP (unsigned char *PictureData){
+    unsigned int Page=0;
+      unsigned int Column=0;
+      
+    // Draw left side of the picture 
+    SelectSide(LEFT);
+      for (Page = 0; Page < 8; Page++){                     /* loop on the 8 pages */            
+              WriteInstruction(LCD_SET_PAGE | Page,LEFT); /* Set the page */
+              for (Column = 0; Column < 64; Column++)
+            WriteData(PictureData[(128*Page)+Column],LEFT);
+    }
+    
+    // Draw right side of the picture
+    SelectSide(RIGHT);
+      for (Page = 0; Page < 8; Page++){                     /* loop on the 8 pages */
+    
+              WriteInstruction(LCD_SET_PAGE| Page,RIGHT); /* Set the page */
+              for (Column = 64; Column < 128; Column++)
+            WriteData(PictureData[(128*Page)+Column],RIGHT);
+    }    
+}
+
+unsigned int KS0108::ReadArrayData(const unsigned int* ptr) { 
+    return (*ptr);
+}
+
+void KS0108::DrawBitmap(const unsigned int * bitmap, unsigned int x, unsigned int y, unsigned int color){
+unsigned int width, height;
+unsigned int i, j;
+
+  width = ReadArrayData(bitmap++); 
+  height = ReadArrayData(bitmap++);
+  for(j = 0; j < height / 8; j++) {
+     GotoXY(x, y + (j*8) );
+     for(i = 0; i < width; i++) {
+         unsigned int displayData = ReadArrayData(bitmap++);
+            if(color == BLACK)
+            WriteData(displayData);
+         else
+            WriteData(~displayData);
+     }
+  }
+}  
+/******************************************************************************************/
+
+
+void KS0108::GotoXY(unsigned int x, unsigned int y) {
+  unsigned int chip, cmd;
+    
+  if( (x > SCREEN_WIDTH-1) || (y > SCREEN_HEIGHT-1) )    // exit if coordinates are not legal
+    return;
+  Coord.x = x;                                    // save new coordinates
+  Coord.y = y;
+    
+  if(y/8 != Coord.page) {
+      Coord.page = y/8;
+    cmd = LCD_SET_PAGE | Coord.page;            // set y address on all chips    
+    for(chip=0; chip < 2; chip++){
+       WriteInstruction(cmd, chip);    
+    }
+  }
+  chip = Coord.x/64;
+  x = x % 64;
+  cmd = LCD_SET_ADD | x;
+  WriteInstruction(cmd, chip);                    // set x address on active chip        
+
+}
+
+
+/*****************************************************************************************/
+
+
+
+void KS0108::Putchar (int page, int col,unsigned char c) {
+    if (c>31 && c<127){
+    for(int i=0;i<5;i++){
+        WriteDataColPag(page,col+i,System5x7[((c-32)*5+i)+6]);
+     }
+    }
+}
+
+
+
+void KS0108::PutString(unsigned int x, unsigned int y,char* str){
+
+    while(*str != 0){
+     Putchar(x,y,*str);
+     str++;
+     y+=System5x7[2];
+    }
+
+}
+
+void KS0108::PrintFloat(float val, unsigned int x,unsigned int y){
+   char buf[20] = {};  // prints up to 20 digits         
+   sprintf(buf,"%f",val);
+   PutString(x,y,buf);
+
+}
+
+
+void KS0108::PrintInteger(int val,unsigned int x,unsigned int y){
+   char buf[20] = {};  // prints up to 20 digits         
+   sprintf(buf,"%d",val);
+   PutString(x,y,buf);
+}
+
+void KS0108::SelectFont(unsigned int* font,unsigned int color, FontCallback callback) {
+    Font = font;
+    FontRead = callback;
+    FontColor = color;
+}
+
+
+int KS0108::PrintChar(char c) {
+    unsigned int width = 0;
+    unsigned int height = FontRead(Font+FONT_HEIGHT);
+    unsigned int bytes = (height+7)/8;
+    
+    unsigned int firstChar = FontRead(Font+FONT_FIRST_CHAR);
+    unsigned int charCount = FontRead(Font+FONT_CHAR_COUNT);
+        
+    unsigned int index = 0;
+    unsigned int x=Coord.x , y=Coord.y;
+
+    if(c < firstChar || c >= (firstChar+charCount)) {
+        return 1;
+    }
+    c-= firstChar;
+
+    if( FontRead(Font+FONT_LENGTH) == 0 && FontRead(Font+FONT_LENGTH+1) == 0) {
+    // zero length is flag indicating fixed width font (array does not contain width data entries)
+       width = FontRead(Font+FONT_FIXED_WIDTH); 
+       index = c*bytes*width+FONT_WIDTH_TABLE;
+    }
+    else{
+    // variable width font, read width data, to get the index
+       for(unsigned int i=0; i<c; i++) {  
+         index += FontRead(Font+FONT_WIDTH_TABLE+i);
+       }
+       index = index*bytes+charCount+FONT_WIDTH_TABLE;
+       width = FontRead(Font+FONT_WIDTH_TABLE+c);
+    }
+
+    // last but not least, draw the character
+    for(unsigned int i=0; i<bytes; i++) {
+        unsigned int page = i*width;
+        for(unsigned int j=0; j<width; j++) {
+            unsigned int data = FontRead(Font+index+page+j);
+        
+            if(height > 8 && height < (i+1)*8) {
+                data >>= (i+1)*8-height;
+            }
+            
+            WriteData(data);
+
+        }
+        // 1px gap between chars
+        WriteData(0x00);
+        GotoXY(x,Coord.y+8);
+    
+    }
+    GotoXY(x+width+1, y);
+    
+
+    return 0;
+}
+
+void KS0108::PrintString(char* str) {
+    int x = Coord.x;
+    while(*str != 0) {
+        if(*str == '\n') {
+            GotoXY(x, Coord.y+ FontRead(Font+FONT_HEIGHT));
+        } else {
+            PrintChar(*str);
+        }
+        str++;
+    }
+}
+
+void KS0108::PrintNumber(long n){
+   char buf[10];  // prints up to 10 digits  
+   char i=0;
+   if(n==0)
+       PrintChar('0');
+   else{
+     if(n < 0){
+        PrintChar('-');
+        n = -n;
+     }
+     while(n>0 && i <= 10){
+       buf[i++] = n % 10;  // n % base
+       n /= 10;   // n/= base
+     }
+     for(; i >0; i--)
+         PrintChar((char) (buf[i-1] < 10 ? '0' + buf[i-1] : 'A' + buf[i-1] - 10));      
+   }
+}
+
+
+
+            
+
+    
diff -r 000000000000 -r 14a7c22dfbe8 KS0108.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/KS0108.h	Mon Jun 18 16:46:41 2012 +0000
@@ -0,0 +1,546 @@
+#ifndef KS0108_H
+#define KS0108_H
+
+#define VERSION 2.0
+
+#include <mbed.h>
+#include "SystemFont5x7.h"
+
+/************************************************************************************/
+// Commands
+#define LCD_ON              0x3F
+#define LCD_OFF             0x3E
+#define LCD_SET_ADD         0x40
+#define LCD_SET_PAGE        0xB8
+#define LCD_DISP_START      0xC0
+
+//Controller directives
+#define LEFT                0
+#define RIGHT               1
+#define BOTH                3
+#define NONE                4
+
+// Colors
+#define BLACK               0xFF
+#define WHITE               0x00
+
+//Screen dimensions
+#define SCREEN_HEIGHT    64
+#define SCREEN_WIDTH    128
+#define CHIP_WIDTH         64
+
+/***********************************************************************************/
+//helper functions 
+
+#define absDiff(x,y) ((x>y) ?  (x-y) : (y-x))
+#define swap(a,b) \
+do\
+{\
+uint8_t t;\
+    t=a;\
+    a=b;\
+    b=t;\
+} while(0)    
+
+/**************************************************************************************/
+
+// Font Indices
+#define FONT_LENGTH         0
+#define FONT_FIXED_WIDTH    2
+#define FONT_HEIGHT         3
+#define FONT_FIRST_CHAR     4
+#define FONT_CHAR_COUNT     5
+#define FONT_WIDTH_TABLE    6
+
+
+/*************************Callback function definietion for fonts *********************/
+typedef unsigned int (*FontCallback)(unsigned int*);
+
+/*************************Callback function    for reading font array*********************/
+static unsigned int ReadData(unsigned int* ptr) {  
+    return *ptr;
+}
+
+/*************************************************************************************/
+#define MAX_IMG_SIZE 128*64
+
+typedef struct {      
+     unsigned int imgWidth;
+    unsigned int imgHeight;         
+    unsigned char imgarray[MAX_IMG_SIZE];
+}Image;
+
+
+typedef struct {
+    unsigned int x;
+    unsigned int y;
+    unsigned int page;
+} LCDCoord;
+
+
+/****************************************************************************************/
+
+
+
+class KS0108  {
+public:
+
+   /**
+    *@brief Constructor, initializes the lcd on the respective pins.
+    *@param control pins     RST,DI,RW,E,CS2,CS1
+    *@param databus        DB0-DB7    data pins
+    *@return none
+    */
+
+    KS0108 (PinName _RST,PinName _DI, PinName _RW, PinName _E, PinName _CS1, PinName _CS2, PinName DB0, PinName DB1, PinName DB2, PinName DB3, PinName DB4, PinName DB5, PinName DB6, PinName DB7);
+
+   /**
+    *@brief Write instruction to the specific controller.
+    *@param Command     command to send to the controller
+    *@param side         controller side can be LEFT or RIGHT
+    *@return none
+    *
+    */
+    void  WriteInstruction(unsigned int Command,unsigned int side);
+
+    /**
+     *@brief Write data byte to the controller.
+     *@param data     data send to the controller chip
+     *@param side     selected controller can be LEFT or RIGHT
+     *@return none
+     *
+     */
+    void  WriteData(unsigned int data ,unsigned char side);
+
+
+    /**
+     *@brief Write data byte to the controller (overloaded function).
+     *
+       *@param data     data send to the controller chip
+     *@return none
+     */
+    void  WriteData(unsigned int data);
+
+    /**
+     *@brief Write data byte to the screen on specific page and column
+     *@param page     page varies from 0-7 for each side
+     *@param col     col varies from 0-64 for each side
+     *@param data     info to be written on given coordinates
+     *@return none
+     *
+     */
+    void  WriteDataColPag(unsigned int page, unsigned int col,  unsigned int data);
+
+    /**
+     *@brief Read data from display
+     *@param none
+     *@return none
+     *
+     */
+    unsigned int ReadData();
+
+    /**
+     *@brief Read status of display , and check if it's busy
+     *@param none
+     *@return status     status of display
+     *
+     */
+    unsigned int ReadStatus();
+
+    /**
+     *@brief Select controller chip
+     *
+     *@param side     controller side can be LEFT or RIGHT
+     *@return none
+     *
+     */
+    void SelectSide(unsigned char side);
+
+    
+       /**
+     *@brief Set cursor to specified coordinates
+     *
+     *@param  x     row
+     *@param  y     column
+     *@return none
+     */
+    void GotoXY(unsigned int x, unsigned int y); 
+
+
+    /**
+     *@brief Clears display
+     *
+     *@param none
+     *@return none
+     *
+     */
+    void ClearScreen();
+    
+    
+    /**
+     *@brief Turn on display
+     *
+     *@param none
+     *@return none
+     *
+     */
+    void TurnOn();
+    
+    
+    /**
+     *@brief Turn Off display
+     *
+     *@param none
+     *@return none
+     *
+     */
+    void TurnOff();
+
+    /*******************************Graphic functions************************************************/
+
+    /**
+    *@brief Set pixel to specific location on the screen.
+    *@param x coordinate varies from 0-128
+    *@param y col varies from 0-64
+    *@param color color of pixel, can be BLACK or WHITE
+    *@return none
+    *
+    */
+    void SetPixel( unsigned int x,  unsigned int y,  unsigned int color);
+
+
+    /**
+     *@brief Draws a line from x1,y1 to x2,y1
+     *@param Xaxis1   x coordinate of one side
+     *@param Xaxis2   x coordinate of one side
+     *@param Yaxis   y coordinate both points
+     *@param color can be BLACK or WHITE
+     *@return none
+     *
+     */
+     void HLine(unsigned int Xaxis1, unsigned int Xaxis2 ,unsigned int Yaxis,unsigned int color);
+
+    /**
+     *@brief Draw a horizontal line
+     *@param Xaxis1
+     *@param Xaxis2
+     *@param width
+     *@param color can be BLACK or WHITE
+     *@return none
+     *
+     */
+    void HLineShort(unsigned int Xaxis, unsigned int Yaxis,unsigned int width ,unsigned int color);
+
+    /**
+     *@brief Draws a vertical line
+     *@param Xaxis
+     *@param Yaxis1
+     *@param Yaxis2
+     *@param color can be BLACK or WHITE
+     *@return none
+     *
+     */
+    void VLine(unsigned int Xaxis, unsigned int Yaxis1 ,unsigned int Yaxis2,unsigned int color);
+
+    /**
+     *@brief Draw a vertical line of a given width starting from X, Y 
+     *@param Xaxis
+     *@param Yaxis
+     *@param height    Height of line
+     *@param color can be BLACK or WHITE
+     *@return none
+     *
+     */
+    void VLineShort(unsigned int Xaxis,unsigned int Yaxis, unsigned int height ,unsigned int color);
+
+
+    /**
+     *@brief Draws a line from x1,y1 to x2,y2.
+     *@param x1   x coordinate of one side
+     *@param y1   y coordinate of one side
+     *@param x2   x coordinate of other side
+     *@param y2   y coordinate of other side
+     *@param color can be BLACK or WHITE
+     *@return none
+     *
+     */
+    void Line(unsigned int x1,unsigned int y1,unsigned int x2,unsigned int y2, unsigned int color);
+
+
+    /**
+     *@brief Draws a slanty line from x1,y1  to x2,y2
+     *@param lX1   x coordinate of one side
+     *@param lY1   y coordinate of one side
+     *@param lX2   x coordinate of other side
+     *@param lY2   y coordinate of other side
+     *@param color can be BLACK or WHITE
+     *@return none
+     *
+     */
+    void SlantyLine(unsigned int lX1, unsigned int lY1, unsigned int lX2,unsigned int lY2,unsigned int color);
+
+    /**
+     *@brief Draws a line from x,y at given degree from inner_radius to outer_radius.
+     *@param x
+     *@param y
+     *@param inner_radius
+     *@param outer_radius
+     *@param color can be BLACK or WHITE
+     *@return none
+     *
+     */
+    void DegreeLine(unsigned int x, int y,unsigned int degree,unsigned int inner_radius,unsigned int outer_radius, unsigned int color);
+
+    /**
+     *@brief Draw a filled rectangle
+     *
+     *@param Xaxis1
+     *@param Yaxis1
+     *@param Xaxis2
+     *@param Yaxis2
+     *@param color can be BLACK or WHITE
+     *@return none
+     *
+     */
+    void FullRectangle(unsigned int Xaxis1, unsigned int Yaxis1, unsigned int Xaxis2 ,unsigned int Yaxis2,unsigned int color);
+    
+    /**
+        Added by Ann
+        Draws a filled rectangle from right to left (instead of left to right)
+    **/
+    void ReverseFullRectangle(unsigned int Xaxis1, unsigned int Yaxis1, unsigned int Xaxis2 ,unsigned int Yaxis2,unsigned int color);
+
+    /**
+     *@brief Draw an empty rectangle
+     *@param Xaxis1
+     *@param Yaxis1
+     *@param Xaxis2
+     *@param Yaxis2
+     *@param color can be BLACK or WHITE
+     *@return none
+     *
+     */
+    void EmptyRectangle(unsigned int Xaxis1,unsigned int Yaxis1, unsigned int Xaxis2,unsigned int Yaxis2,unsigned int color);
+
+
+    /**
+     *@brief Draw a rectangle with round corners
+     *@param Xaxis1 x-coordinate of the top left point
+     *@param Yaxis1 y-coordinate of the top left point
+     *@param width  rectangle width
+     *@param height rectangle height
+     *@param radius radius of the edges
+     *@param color can be BLACK or WHITE
+     *@return none
+     *
+     */
+    void RoundRectangle(unsigned int x, unsigned int y, unsigned int width, unsigned int height, unsigned int radius, unsigned int color);
+
+      
+    /**
+     *Draws a triangle .
+     *@param 
+     *@param 
+     *@param 
+     *@param 
+     *@return none
+     *
+     */
+    
+    void Triangle ( int topx, int topy, int rightx, int righty);
+    
+
+    /**
+     *Draws a right angle triangle .
+     *@param 
+     *@param 
+     *@param 
+     *@param 
+     *@return none
+     *
+     */
+    void RightTriangle ( int topx, int topy, int rightx, int righty);
+
+
+    /**
+     *Draws an empty circle centered a x,y with radius R and specific color.
+     *@param CenterX   center x coordinate 
+     *@param CenterY   center y coordinate
+     *@param Radius    circle radius
+     *@param color     Color can be BLACK or WHITE
+     *@return none
+     *
+     */
+    void EmptyCircle(unsigned int CenterX, unsigned int CenterY, unsigned int Radius,unsigned int color);
+
+    /**
+     * Circle fill Code is merely a modification of the midpoint
+     * circle algorithem which is an adaption of Bresenham's line algorithm
+     * http://en.wikipedia.org/wiki/Midpoint_circle_algorithm
+     * http://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm
+     * Adapted from arduino lib
+     *
+     *@param  CenterX center x coordinate
+     *@param CenterY  center y coordinate
+     *@param Radius   circle radius
+     *@param color    Color can be BLACK or WHITE
+     */
+    void FullCircle(unsigned int CenterX, unsigned int CenterY, unsigned int Radius,unsigned int color);
+
+    /**
+     *Draws an ellipse.
+     *@param CX   x coordinate of one side
+     *@param CY   y coordinate of one side
+     *@param XRadius   x coordinate of other side
+     *@param YRadius   y coordinate of other side
+     *@param color can be BLACK or WHITE
+     *@return none
+     *
+     * Ported the algorithm found at http://homepage.smc.edu/kennedy_john/belipse.pdf
+     *
+     */
+    void PlotEllipse(long CX, long  CY, long XRadius,long YRadius, int color);
+    void Plot4EllipsePoints(long CX,long  CY, long X, long Y, int color);
+
+    
+    /**
+     *@brief Round a double
+     *@param double
+     *@return value
+     *
+     */
+    double dfloor( double value );
+
+
+    /*****************************Bitmaps *****************************************************************/
+    
+    /**
+     *@brief Draws an image on screen.
+     *@param PictureData  128x64 image array
+     *@return none
+     *
+     *
+     */
+    void FullScreenBMP (unsigned char *ImageData);
+
+    /**
+     *@brief Draw a 1-bit bitmap
+      *
+     *@param  image struct containing img size and array
+     *@param x x-coordinate
+     *@param y y-coordinate
+     *@param color can be BLACK or WHITE
+     *@return none
+     */
+    void DrawBitmap(const unsigned int * bitmap, unsigned int x, unsigned int y, unsigned int color);
+
+    /**
+     *@brief Static function , mplemented to read an array
+     *@param  ptr     data array
+     *@return none
+     */
+    unsigned int ReadArrayData(const unsigned int* ptr); 
+
+   
+    /*************************************Font functions **************************************/
+
+   /**
+    *@brief Print a character on specified coordinates
+    *
+    *@param  page     row
+    *@param  col     column
+    *@param  c     integer value
+    *@return none 
+    */
+    void Putchar (int page, int col,unsigned char c);
+
+   /**
+    *@brief Print a string on specified coordinates
+    *
+    *@param  str     char array
+    *@param  x     row
+    *@param  y     column 
+    *@return none 
+    */
+    void PutString(unsigned int x, unsigned int y,char* str);
+
+   /**
+    *@brief Print a float on specified coordinates
+    *
+    *@param  val     float value
+    *@param  x     row
+    *@param  y     column
+    *@return none 
+    */
+    void PrintFloat(float val, unsigned int x,unsigned int y);
+
+   /**
+    *@brief Print an integer on specified coordinates
+    *
+    *@param  val     integer value
+    *@param  x     row
+    *@param  y     column
+    *@return none 
+    */ 
+    void PrintInteger(int val,unsigned int x,unsigned int y);
+
+
+   /**
+    *@brief Select a specific font
+    *
+    *@param  font          font array
+    *@param  color         font color , can be BLACK or WHITE
+    *@param  callback    function pointer to load font
+    *@return none 
+    */
+    void SelectFont(unsigned int* font,unsigned int color, FontCallback callback);
+
+    
+    /**
+     *@brief Print a character
+     *
+     *@param  c     char
+     *@return none
+     */
+    int PrintChar(char c);
+
+    
+    /**
+     *@brief Print a character string 
+     *
+     *@param  str     char string
+     *@return none
+     */
+    void PrintString(char* str);
+    
+    
+    /**
+     *@brief Print a number 
+     *
+     *@param  n     number
+     *@return none
+     */
+    void PrintNumber(long n);      
+                                   
+    
+private:
+    BusInOut DB;
+    DigitalOut RST;
+    DigitalOut DI;
+    DigitalOut RW;
+    DigitalOut E;
+    DigitalInOut CS2;
+    DigitalInOut CS1;
+    bool    Inverted;                  
+    
+    LCDCoord                Coord;
+    FontCallback            FontRead ;
+    unsigned int            FontColor;
+    unsigned int*            Font;
+    unsigned int color;
+
+   
+};
+
+
+#endif
diff -r 000000000000 -r 14a7c22dfbe8 MyPhone_20.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/MyPhone_20.h	Mon Jun 18 16:46:41 2012 +0000
@@ -0,0 +1,70 @@
+
+
+/*
+ *
+ * MyPhone_20
+ *
+ * created with FontCreator
+ * written by F. Maximilian Thiele
+ *
+ * http://www.apetech.de/fontCreator
+ * me@apetech.de
+ *
+ * File Name           : MyPhone_20.h
+ * Date                : 14.04.2012
+ * Font size in bytes  : 896
+ * Font width          : 10
+ * Font height         : 11
+ * Font first char     : 48
+ * Font last char      : 58
+ * Font used chars     : 10
+ *
+ * The font data are defined as
+ *
+ * struct _FONT_ {
+ *     uint16_t   font_Size_in_Bytes_over_all_included_Size_it_self;
+ *     uint8_t    font_Width_in_Pixel_for_fixed_drawing;
+ *     uint8_t    font_Height_in_Pixel_for_all_characters;
+ *     unit8_t    font_First_Char;
+ *     uint8_t    font_Char_Count;
+ *
+ *     uint8_t    font_Char_Widths[font_Last_Char - font_First_Char +1];
+ *                  // for each character the separate width in pixels,
+ *                  // characters < 128 have an implicit virtual right empty row
+ *
+ *     uint8_t    font_data[];
+ *                  // bit field of all characters
+ */
+
+#ifndef MYPHONE_20_H
+#define MYPHONE_20_H
+
+#define MYPHONE_20_WIDTH 10
+#define MYPHONE_20_HEIGHT 11
+
+static unsigned int MyPhone_20[] = {
+    0x03, 0x80, // size
+    0x0A, // width
+    0x0B, // height
+    0x30, // first char
+    0x0A, // char count
+    
+    // char widths
+    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 
+    
+    
+    // font data
+    0xFE, 0xFF, 0xFF, 0x01, 0x01, 0xFF, 0xFE, 0xFE, 0x60, 0xE0, 0xE0, 0x80, 0x80, 0xE0, 0x60, 0x60, // 48
+    0x0C, 0x02, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x80, 0x80, 0xE0, 0xE0, 0xE0, 0x80, 0x80, 0x80, // 49
+    0x02, 0x83, 0xC3, 0xC1, 0x61, 0x3F, 0x1E, 0x1E, 0xE0, 0xE0, 0xE0, 0xA0, 0x80, 0x80, 0x80, 0x80, // 50
+    0x02, 0x03, 0x23, 0x21, 0x21, 0xFF, 0xDE, 0xDE, 0x60, 0xE0, 0xE0, 0x80, 0x80, 0xE0, 0x60, 0x60, // 51
+    0xE0, 0x9C, 0x9E, 0x82, 0xFF, 0xFF, 0x80, 0x80, 0x20, 0x20, 0x20, 0x20, 0xE0, 0xE0, 0x20, 0x20, // 52
+    0x1F, 0x1F, 0x1F, 0x19, 0x19, 0xF9, 0xE1, 0xE1, 0x60, 0xE0, 0xE0, 0x80, 0x80, 0xE0, 0x60, 0x60, // 53
+    0xFC, 0xFE, 0xFF, 0x23, 0x21, 0xE1, 0xC0, 0xC0, 0x60, 0xE0, 0xE0, 0x80, 0x80, 0xE0, 0x60, 0x60, // 54
+    0x01, 0x81, 0xE1, 0xE1, 0x7D, 0x1F, 0x03, 0x03, 0x00, 0xE0, 0xE0, 0xE0, 0x00, 0x00, 0x00, 0x00, // 55
+    0xDE, 0xFF, 0xFF, 0x21, 0x21, 0xFF, 0xDE, 0xDE, 0x60, 0xE0, 0xE0, 0x80, 0x80, 0xE0, 0x60, 0x60, // 56
+    0x1E, 0x3F, 0x3F, 0x21, 0x21, 0xFF, 0xFE, 0xFE, 0x00, 0x80, 0x80, 0x80, 0xE0, 0x60, 0x20, 0x20 // 57
+    
+};
+
+#endif
diff -r 000000000000 -r 14a7c22dfbe8 MyPhone_40.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/MyPhone_40.h	Mon Jun 18 16:46:41 2012 +0000
@@ -0,0 +1,69 @@
+
+
+/*
+ *
+ * MyPhone_40
+ *
+ * created with FontCreator
+ * written by F. Maximilian Thiele
+ *
+ * http://www.apetech.de/fontCreator
+ * me@apetech.de
+ *
+ * File Name           : MyPhone_40.h
+ * Date                : 14.04.2012
+ * Font size in bytes  : 3466
+ * Font width          : 10
+ * Font height         : 23
+ * Font first char     : 48
+ * Font last char      : 58
+ * Font used chars     : 10
+ *
+ * The font data are defined as
+ *
+ * struct _FONT_ {
+ *     uint16_t   font_Size_in_Bytes_over_all_included_Size_it_self;
+ *     uint8_t    font_Width_in_Pixel_for_fixed_drawing;
+ *     uint8_t    font_Height_in_Pixel_for_all_characters;
+ *     unit8_t    font_First_Char;
+ *     uint8_t    font_Char_Count;
+ *
+ *     uint8_t    font_Char_Widths[font_Last_Char - font_First_Char +1];
+ *                  // for each character the separate width in pixels,
+ *                  // characters < 128 have an implicit virtual right empty row
+ *
+ *     uint8_t    font_data[];
+ *                  // bit field of all characters
+ */
+#ifndef MYPHONE_40_H
+#define MYPHONE_40_H
+
+#define MYPHONE_40_WIDTH 10
+#define MYPHONE_40_HEIGHT 23
+
+static unsigned int MyPhone_40[] = {
+    0x0D, 0x8A, // size
+    0x0A, // width
+    0x17, // height
+    0x30, // first char
+    0x0A, // char count
+    
+    // char widths
+    0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 
+    
+    
+    // font data
+    0xF8, 0xF8, 0xFF, 0xFF, 0xFF, 0x07, 0x07, 0x07, 0x07, 0x07, 0xFF, 0xFF, 0xFF, 0xF8, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3E, 0x3E, 0xFE, 0xFE, 0xFE, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xFE, 0xFE, 0xFE, 0x3E, 0x3E, // 48
+    0xE0, 0xE0, 0xF8, 0x38, 0x38, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, // 49
+    0x38, 0x38, 0x3F, 0x3F, 0x3F, 0x07, 0x07, 0x07, 0x07, 0x07, 0xFF, 0xFF, 0xFF, 0xF8, 0xF8, 0x00, 0x00, 0x80, 0x80, 0x80, 0xE0, 0xE0, 0xFC, 0xFC, 0xFC, 0x1F, 0x1F, 0x1F, 0x07, 0x07, 0xF8, 0xF8, 0xFE, 0xFE, 0xFE, 0xE6, 0xE6, 0xE6, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, // 50
+    0x38, 0x38, 0x3F, 0x3F, 0x3F, 0x07, 0x07, 0x07, 0x07, 0x07, 0xFF, 0xFF, 0xFF, 0xF8, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0xFF, 0xFF, 0xFF, 0xE7, 0xE7, 0x38, 0x38, 0xF8, 0xF8, 0xF8, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xFE, 0xFE, 0xFE, 0x3E, 0x3E, // 51
+    0x00, 0x00, 0xE0, 0xE0, 0xE0, 0x38, 0x38, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xFC, 0xFC, 0xFF, 0x87, 0x87, 0x80, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x80, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0x06, 0x06, // 52
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0xFF, 0xFF, 0xFF, 0xFC, 0xFC, 0x38, 0x38, 0xF8, 0xF8, 0xF8, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xFE, 0xFE, 0xFE, 0x3E, 0x3E, // 53
+    0xE0, 0xE0, 0xF8, 0xF8, 0xF8, 0x3F, 0x3F, 0x3F, 0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0xFC, 0xFC, 0xFC, 0xE0, 0xE0, 0x3E, 0x3E, 0xFE, 0xFE, 0xFE, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xFE, 0xFE, 0xFE, 0x3E, 0x3E, // 54
+    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0xE7, 0xE7, 0xE7, 0xFF, 0xFF, 0xFF, 0x3F, 0x3F, 0x00, 0x00, 0x80, 0x80, 0x80, 0xFC, 0xFC, 0xFF, 0xFF, 0xFF, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 55
+    0xF8, 0xF8, 0xFF, 0xFF, 0xFF, 0x07, 0x07, 0x07, 0x07, 0x07, 0xFF, 0xFF, 0xFF, 0xF8, 0xF8, 0xE7, 0xE7, 0xFF, 0xFF, 0xFF, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0xFF, 0xFF, 0xFF, 0xE7, 0xE7, 0x3E, 0x3E, 0xFE, 0xFE, 0xFE, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xFE, 0xFE, 0xFE, 0x3E, 0x3E, // 56
+    0xF8, 0xF8, 0xFF, 0xFF, 0xFF, 0x07, 0x07, 0x07, 0x07, 0x07, 0xFF, 0xFF, 0xFF, 0xF8, 0xF8, 0x07, 0x07, 0x1F, 0x1F, 0x1F, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xF8, 0xF8, 0xF8, 0x3E, 0x3E, 0x3E, 0x06, 0x06 // 57
+    
+};
+
+#endif
diff -r 000000000000 -r 14a7c22dfbe8 SystemFont5x7.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SystemFont5x7.h	Mon Jun 18 16:46:41 2012 +0000
@@ -0,0 +1,147 @@
+/*
+ *
+ * System5x7
+ *
+ *
+ * File Name           : System5x7.h
+ * Date                : 28 Oct 2008
+ * Font size in bytes  : 470
+ * Font width          : 5
+ * Font height         : 7
+ * Font first char     : 32
+ * Font last char      : 127
+ * Font used chars     : 94
+ *
+ * The font data are defined as
+ *
+ * struct _FONT_ {
+ *     uint16_t   font_Size_in_Bytes_over_all_included_Size_it_self;
+ *     uint8_t    font_Width_in_Pixel_for_fixed_drawing;
+ *     uint8_t    font_Height_in_Pixel_for_all_characters;
+ *     unit8_t    font_First_Char;
+ *     uint8_t    font_Char_Count;
+ *
+ *     uint8_t    font_Char_Widths[font_Last_Char - font_First_Char +1];
+ *                  // for each character the separate width in pixels,
+ *                  // characters < 128 have an implicit virtual right empty row
+ *
+ *     uint8_t    font_data[];
+ *                  // bit field of all characters
+ */
+
+#ifndef SYSTEM5x7_H
+#define SYSTEM5x7_H
+
+#define SYSTEM5x7_WIDTH 5
+#define SYSTEM5x7_HEIGHT 7
+
+static unsigned int System5x7[]  = {
+    0x0, 0x0,     // size of zero indicates fixed width font, actual length is width * height
+    0x05,         // width
+    0x07,         // height
+    0x20,         // first char
+    0x7f,         // char count
+    
+    // Fixed width; char width table not used !!!!
+    
+    // font data
+    0x00, 0x00, 0x00, 0x00, 0x00,// (space)
+    0x00, 0x00, 0x5F, 0x00, 0x00,// !
+    0x00, 0x07, 0x00, 0x07, 0x00,// "
+    0x14, 0x7F, 0x14, 0x7F, 0x14,// #
+    0x24, 0x2A, 0x7F, 0x2A, 0x12,// $
+    0x23, 0x13, 0x08, 0x64, 0x62,// %
+    0x36, 0x49, 0x55, 0x22, 0x50,// &
+    0x00, 0x05, 0x03, 0x00, 0x00,// '
+    0x00, 0x1C, 0x22, 0x41, 0x00,// (
+    0x00, 0x41, 0x22, 0x1C, 0x00,// )
+    0x08, 0x2A, 0x1C, 0x2A, 0x08,// *
+    0x08, 0x08, 0x3E, 0x08, 0x08,// +
+    0x00, 0x50, 0x30, 0x00, 0x00,// ,
+    0x08, 0x08, 0x08, 0x08, 0x08,// -
+    0x00, 0x60, 0x60, 0x00, 0x00,// .
+    0x20, 0x10, 0x08, 0x04, 0x02,// /
+    0x3E, 0x51, 0x49, 0x45, 0x3E,// 0
+    0x00, 0x42, 0x7F, 0x40, 0x00,// 1
+    0x42, 0x61, 0x51, 0x49, 0x46,// 2
+    0x21, 0x41, 0x45, 0x4B, 0x31,// 3
+    0x18, 0x14, 0x12, 0x7F, 0x10,// 4
+    0x27, 0x45, 0x45, 0x45, 0x39,// 5
+    0x3C, 0x4A, 0x49, 0x49, 0x30,// 6
+    0x01, 0x71, 0x09, 0x05, 0x03,// 7
+    0x36, 0x49, 0x49, 0x49, 0x36,// 8
+    0x06, 0x49, 0x49, 0x29, 0x1E,// 9
+    0x00, 0x36, 0x36, 0x00, 0x00,// :
+    0x00, 0x56, 0x36, 0x00, 0x00,// ;
+    0x00, 0x08, 0x14, 0x22, 0x41,// <
+    0x14, 0x14, 0x14, 0x14, 0x14,// =
+    0x41, 0x22, 0x14, 0x08, 0x00,// >
+    0x02, 0x01, 0x51, 0x09, 0x06,// ?
+    0x32, 0x49, 0x79, 0x41, 0x3E,// @
+    0x7E, 0x11, 0x11, 0x11, 0x7E,// A
+    0x7F, 0x49, 0x49, 0x49, 0x36,// B
+    0x3E, 0x41, 0x41, 0x41, 0x22,// C
+    0x7F, 0x41, 0x41, 0x22, 0x1C,// D
+    0x7F, 0x49, 0x49, 0x49, 0x41,// E
+    0x7F, 0x09, 0x09, 0x01, 0x01,// F
+    0x3E, 0x41, 0x41, 0x51, 0x32,// G
+    0x7F, 0x08, 0x08, 0x08, 0x7F,// H
+    0x00, 0x41, 0x7F, 0x41, 0x00,// I
+    0x20, 0x40, 0x41, 0x3F, 0x01,// J
+    0x7F, 0x08, 0x14, 0x22, 0x41,// K
+    0x7F, 0x40, 0x40, 0x40, 0x40,// L
+    0x7F, 0x02, 0x04, 0x02, 0x7F,// M
+    0x7F, 0x04, 0x08, 0x10, 0x7F,// N
+    0x3E, 0x41, 0x41, 0x41, 0x3E,// O
+    0x7F, 0x09, 0x09, 0x09, 0x06,// P
+    0x3E, 0x41, 0x51, 0x21, 0x5E,// Q
+    0x7F, 0x09, 0x19, 0x29, 0x46,// R
+    0x46, 0x49, 0x49, 0x49, 0x31,// S
+    0x01, 0x01, 0x7F, 0x01, 0x01,// T
+    0x3F, 0x40, 0x40, 0x40, 0x3F,// U
+    0x1F, 0x20, 0x40, 0x20, 0x1F,// V
+    0x7F, 0x20, 0x18, 0x20, 0x7F,// W
+    0x63, 0x14, 0x08, 0x14, 0x63,// X
+    0x03, 0x04, 0x78, 0x04, 0x03,// Y
+    0x61, 0x51, 0x49, 0x45, 0x43,// Z
+    0x00, 0x00, 0x7F, 0x41, 0x41,// [
+    0x02, 0x04, 0x08, 0x10, 0x20,// "\"
+    0x41, 0x41, 0x7F, 0x00, 0x00,// ]
+    0x04, 0x02, 0x01, 0x02, 0x04,// ^
+    0x40, 0x40, 0x40, 0x40, 0x40,// _
+    0x00, 0x01, 0x02, 0x04, 0x00,// `
+    0x20, 0x54, 0x54, 0x54, 0x78,// a
+    0x7F, 0x48, 0x44, 0x44, 0x38,// b
+    0x38, 0x44, 0x44, 0x44, 0x20,// c
+    0x38, 0x44, 0x44, 0x48, 0x7F,// d
+    0x38, 0x54, 0x54, 0x54, 0x18,// e
+    0x08, 0x7E, 0x09, 0x01, 0x02,// f
+    0x08, 0x14, 0x54, 0x54, 0x3C,// g
+    0x7F, 0x08, 0x04, 0x04, 0x78,// h
+    0x00, 0x44, 0x7D, 0x40, 0x00,// i
+    0x20, 0x40, 0x44, 0x3D, 0x00,// j
+    0x00, 0x7F, 0x10, 0x28, 0x44,// k
+    0x00, 0x41, 0x7F, 0x40, 0x00,// l
+    0x7C, 0x04, 0x18, 0x04, 0x78,// m
+    0x7C, 0x08, 0x04, 0x04, 0x78,// n
+    0x38, 0x44, 0x44, 0x44, 0x38,// o
+    0x7C, 0x14, 0x14, 0x14, 0x08,// p
+    0x08, 0x14, 0x14, 0x18, 0x7C,// q
+    0x7C, 0x08, 0x04, 0x04, 0x08,// r
+    0x48, 0x54, 0x54, 0x54, 0x20,// s
+    0x04, 0x3F, 0x44, 0x40, 0x20,// t
+    0x3C, 0x40, 0x40, 0x20, 0x7C,// u
+    0x1C, 0x20, 0x40, 0x20, 0x1C,// v
+    0x3C, 0x40, 0x30, 0x40, 0x3C,// w
+    0x44, 0x28, 0x10, 0x28, 0x44,// x
+    0x0C, 0x50, 0x50, 0x50, 0x3C,// y
+    0x44, 0x64, 0x54, 0x4C, 0x44,// z
+    0x00, 0x08, 0x36, 0x41, 0x00,// {
+    0x00, 0x00, 0x7F, 0x00, 0x00,// |
+    0x00, 0x41, 0x36, 0x08, 0x00,// }
+    0x08, 0x08, 0x2A, 0x1C, 0x08,// ->
+    0x08, 0x1C, 0x2A, 0x08, 0x08 // <-
+    
+};
+
+#endif