Dependencies:   mbed

Revision:
0:87b78725a6dd
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/KS0108/KS0108.cpp	Mon Mar 05 06:00:16 2012 +0000
@@ -0,0 +1,835 @@
+#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::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));      
+   }
+}
+
+
+
+            
+
+    
+