lcd.c

00001 #include <stdarg.h>
00002 #include "lcd.h"
00003 
00004 void lcd_init(lcd_t * lcd, spi_t * spi, PinName CS, PinName CD) {
00005     //Prepare pins
00006     gpio_init_out(&(lcd->CS), CS );
00007     gpio_init_out(&(lcd->CD), CD);
00008 
00009     gpio_write(&(lcd->CS), 1);
00010     gpio_write(&(lcd->CD), 1);
00011     //
00012     
00013     lcd->mode = PORTRAIT;
00014     //lcd->mode = LANDSCAPE;
00015     lcd->spi = spi;
00016         
00017     wait_ms(500);
00018     lcd_writeCommand(lcd, 0x01);
00019     wait_ms(200);
00020     
00021 
00022     lcd_writeCommand(lcd, 0xCF);
00023     lcd_writeData(lcd, 0x00);
00024     lcd_writeData(lcd, 0x8B);
00025     lcd_writeData(lcd, 0x30);
00026     
00027     lcd_writeCommand(lcd, 0xED);
00028     lcd_writeData(lcd, 0x67);
00029     lcd_writeData(lcd, 0x03);
00030     lcd_writeData(lcd, 0x12);
00031     lcd_writeData(lcd, 0x81);
00032 
00033     lcd_writeCommand(lcd, 0xE8);
00034     lcd_writeData(lcd, 0x85);
00035     lcd_writeData(lcd, 0x10);
00036     lcd_writeData(lcd, 0x7A);
00037 
00038     lcd_writeCommand(lcd, 0xCB);
00039     lcd_writeData(lcd, 0x39);
00040     lcd_writeData(lcd, 0x2C);
00041     lcd_writeData(lcd, 0x00);
00042     lcd_writeData(lcd, 0x34);
00043     lcd_writeData(lcd, 0x02);
00044 
00045     lcd_writeCommand(lcd, 0xF7);
00046     lcd_writeData(lcd, 0x20);
00047 
00048     lcd_writeCommand(lcd, 0xEA);
00049     lcd_writeData(lcd, 0x00);
00050     lcd_writeData(lcd, 0x00);
00051 
00052     lcd_writeCommand(lcd, 0xC0); /* Power control */
00053     lcd_writeData(lcd, 0x1B); /* VRH[5:0] */
00054 
00055     lcd_writeCommand(lcd, 0xC1); /* Power control */
00056     lcd_writeData(lcd, 0x10); /* SAP[2:0];BT[3:0] */
00057 
00058     lcd_writeCommand(lcd, 0xC5); /* VCM control */
00059     lcd_writeData(lcd, 0x3F);
00060     lcd_writeData(lcd, 0x3C);
00061 
00062     lcd_writeCommand(lcd, 0xC7); /* VCM control2 */
00063     lcd_writeData(lcd, 0xB7);
00064 
00065     lcd_writeCommand(lcd, 0x36); /* Memory Access Control */
00066     lcd_writeData(lcd, 0x08);
00067 
00068     lcd_writeCommand(lcd, 0x3A);
00069     lcd_writeData(lcd, 0x55);
00070 
00071     lcd_writeCommand(lcd, 0xB1);
00072     lcd_writeData(lcd, 0x00);
00073     lcd_writeData(lcd, 0x1B);
00074 
00075     lcd_writeCommand(lcd, 0xB6); /* Display Function Control */
00076     lcd_writeData(lcd, 0x0A);
00077     lcd_writeData(lcd, 0xA2);
00078 
00079     lcd_writeCommand(lcd, 0xF2); /* 3Gamma Function Disable */
00080     lcd_writeData(lcd, 0x00);
00081 
00082     lcd_writeCommand(lcd, 0x26); /* Gamma curve selected */
00083     lcd_writeData(lcd, 0x01);
00084 
00085     lcd_writeCommand(lcd, 0xE0); /* Set Gamma */
00086     lcd_writeData(lcd, 0x0F);
00087     lcd_writeData(lcd, 0x2A);
00088     lcd_writeData(lcd, 0x28);
00089     lcd_writeData(lcd, 0x08);
00090     lcd_writeData(lcd, 0x0E);
00091     lcd_writeData(lcd, 0x08);
00092     lcd_writeData(lcd, 0x54);
00093     lcd_writeData(lcd, 0xA9);
00094     lcd_writeData(lcd, 0x43);
00095     lcd_writeData(lcd, 0x0A);
00096     lcd_writeData(lcd, 0x0F);
00097     lcd_writeData(lcd, 0x00);
00098     lcd_writeData(lcd, 0x00);
00099     lcd_writeData(lcd, 0x00);
00100     lcd_writeData(lcd, 0x00);
00101 
00102     lcd_writeCommand(lcd, 0xE1); /* Set Gamma */
00103     lcd_writeData(lcd, 0x00);
00104     lcd_writeData(lcd, 0x15);
00105     lcd_writeData(lcd, 0x17);
00106     lcd_writeData(lcd, 0x07);
00107     lcd_writeData(lcd, 0x11);
00108     lcd_writeData(lcd, 0x06);
00109     lcd_writeData(lcd, 0x2B);
00110     lcd_writeData(lcd, 0x56);
00111     lcd_writeData(lcd, 0x3C);
00112     lcd_writeData(lcd, 0x05);
00113     lcd_writeData(lcd, 0x10);
00114     lcd_writeData(lcd, 0x0F);
00115     lcd_writeData(lcd, 0x3F);
00116     lcd_writeData(lcd, 0x3F);
00117     lcd_writeData(lcd, 0x0F);
00118 
00119     lcd_writeCommand(lcd, 0x11); /* Exit Sleep */
00120     wait_ms(120);
00121     lcd_writeCommand(lcd, 0x29);
00122     lcd_fillScreen(lcd);
00123 }
00124 
00125 void lcd_cs(lcd_t * lcd, int value) {
00126     while(spi_busy(lcd->spi));
00127     gpio_write(&(lcd->CS), value);
00128 }
00129 
00130 void lcd_cd(lcd_t * lcd, int value) {
00131     while(spi_busy(lcd->spi));
00132     gpio_write(&(lcd->CD), value);
00133 }
00134 
00135 void lcd_setMode(lcd_t * lcd, lcd_mode mode) {
00136     lcd->mode = mode;
00137 }
00138 
00139 void lcd_writeCommand(lcd_t * lcd, int value) {  
00140     lcd_cd(lcd, 0);
00141     lcd_cs(lcd, 0);
00142     
00143     spi_master_write(lcd->spi, value);
00144     
00145     lcd_cs(lcd, 1);
00146 }
00147 
00148 void lcd_writeData(lcd_t * lcd, int value) {
00149     lcd_cd(lcd, 1);
00150     lcd_cs(lcd, 0);
00151     
00152     spi_master_write(lcd->spi, value);
00153     
00154     lcd_cs(lcd, 1);
00155 }
00156 
00157 void lcd_writeData16(lcd_t * lcd, int value) {
00158     int data1 = value >> 8;
00159     int data2 = value & 0xff;
00160     lcd_cd(lcd, 1);
00161     lcd_cs(lcd, 0);
00162     
00163     spi_master_write(lcd->spi, data1);
00164     spi_master_write(lcd->spi, data2);
00165     
00166     lcd_cs(lcd, 1);
00167 }
00168 
00169 void lcd_setColumn(lcd_t * lcd, int start, int end) {
00170     lcd_writeCommand(lcd, 0x2A);  /* column command address */
00171     lcd_writeData16(lcd, start);
00172     lcd_writeData16(lcd, end);
00173 }
00174 
00175 void lcd_setPage(lcd_t * lcd, int start, int end) {
00176     lcd_writeCommand(lcd, 0x2B);  /* column command address */
00177     lcd_writeData16(lcd, start);
00178     lcd_writeData16(lcd, end);
00179 }
00180 
00181 void lcd_setXY(lcd_t * lcd, int x, int y) {
00182     lcd_setColumn(lcd, x, x);
00183     lcd_setPage(lcd, y, y);
00184     lcd_writeCommand(lcd, 0x2c);
00185 }
00186 
00187 void lcd_setPixel(lcd_t * lcd, int x, int y, int color) {
00188     lcd_setXY(lcd, x, y);
00189     lcd_writeData16(lcd, color);
00190 }
00191 
00192 void lcd_setLandscape(lcd_t * lcd) {
00193     lcd->mode = LANDSCAPE;
00194 }
00195 
00196 void lcd_setPortrait(lcd_t * lcd) {
00197     lcd->mode = PORTRAIT;
00198 }
00199 
00200 void lcd_fillScreen(lcd_t * lcd) {
00201     lcd_setColumn(lcd, 0, 239);
00202     lcd_setPage(lcd, 0, 319);
00203     lcd_writeCommand(lcd, 0x2c);  /* start to write to display ram */
00204 
00205     lcd_cd(lcd, 1);
00206     lcd_cs(lcd, 0);
00207     for(int i = 0; i < 76800; i++)
00208     {
00209         spi_master_write(lcd->spi, 0xFF); 
00210         spi_master_write(lcd->spi, 0xFF); 
00211     }
00212     while(spi_busy(lcd->spi));
00213     lcd_cs(lcd, 1);
00214 }
00215 
00216 void lcd_drawLine(lcd_t * lcd, int x0, int y0, int x1, int y1, int color) {
00217     if (x0 == x1) {
00218         lcd_drawVerticalLine(lcd, x0, y0, y1-y0, color);
00219     }else if (y0 == y1) {
00220         lcd_drawHorizontalLine(lcd, x0, y0, x1-x0, color);
00221     }else {  
00222         if(lcd->mode == LANDSCAPE) {
00223             y0 = y0^x0;
00224             x0 = y0^x0;
00225             y0 = y0^x0;
00226             
00227             y1 = y1^x1;
00228             x1 = y1^x1;
00229             y1 = y1^x1;
00230             
00231             x0 = 239-(x0);
00232             x1 = 239-(x1);
00233         }
00234         int x = x1-x0;
00235         int y = y1-y0;
00236         int dx = abs(x), sx = x0 < x1 ? 1 : -1;
00237         int dy = -abs(y), sy = y0 < y1 ? 1 : -1;
00238         int err = dx + dy, e2;                          /* error value e_xy */
00239 
00240         lcd_setPixel(lcd, x0, y0, color);
00241     
00242         do
00243         {
00244             e2 = 2*err;
00245             
00246             if (e2 >= dy) {                              /* e_xy+e_x > 0 */
00247                 err += dy; x0 += sx;
00248             }
00249             
00250             if (e2 <= dx) {                              /* e_xy+e_y < 0 */
00251                 err += dx; y0 += sy;
00252             }
00253             
00254             lcd_setPixel(lcd, x0, y0, color);
00255         } while (x0 != x1 || y0 != y1);
00256     }
00257 }
00258 
00259 void lcd_drawVerticalLine(lcd_t * lcd, int x, int y, int length, int color) {
00260     if(lcd->mode == LANDSCAPE) {
00261         y = y^x;
00262         x = y^x;
00263         y = y^x;
00264         x = 239-(x);
00265     }
00266 
00267     lcd_setColumn(lcd, x, x);
00268     lcd_setPage(lcd, y, y + length);
00269     
00270     lcd_writeCommand(lcd, 0x2c);
00271     for(int i=0; i<length; i++)
00272         lcd_writeData16(lcd, color);
00273 }
00274 
00275 void lcd_drawHorizontalLine(lcd_t * lcd, int x, int y, int length, int color) {
00276     if(lcd->mode == LANDSCAPE) {
00277         y = y^x;
00278         x = y^x;
00279         y = y^x;
00280         x = 239-x;
00281         lcd_setColumn(lcd, x - length, x);
00282     }else {
00283         lcd_setColumn(lcd, x, x + length);
00284     }
00285     
00286     lcd_setPage(lcd, y, y);
00287     
00288     lcd_writeCommand(lcd, 0x2c);
00289     for(int i=0; i<length; i++)
00290         lcd_writeData16(lcd, color);
00291 }
00292 
00293 void lcd_drawRectangle(lcd_t * lcd , int x0, int y0, int x1, int y1, int color) {
00294     if(x0>x1) {
00295         x0=x0^x1;
00296         x1=x0^x1;
00297         x0=x0^x1;
00298     }
00299     
00300     if(y0>y1) {
00301         y0=y0^y1;
00302         y1=y0^y1;
00303         y0=y0^y1;
00304     }  
00305     
00306     lcd_drawVerticalLine(lcd, x0, y0, y1-y0, color);
00307     lcd_drawVerticalLine(lcd, x0, y1, y1-y0, color);
00308     lcd_drawHorizontalLine(lcd, x0, y0, x1-x0, color);
00309     lcd_drawHorizontalLine(lcd, x1, y0, x1-x0, color);
00310 }
00311 
00312 void lcd_fillRectangle(lcd_t * lcd, int x0, int y0, int length, int width, int color) {    
00313     int XY=0;
00314     
00315     int x1 = x0+length;
00316     int y1 = y0+width;
00317 
00318     if(x0 > x1)
00319     {
00320         x0 = x0^x1;
00321         x1 = x0^x1;
00322         x0 = x0^x1;
00323     }
00324     
00325     if(y0 > y1)
00326     {
00327         y0 = y0^y1;
00328         y1 = y0^y1;
00329         y0 = y0^y1;
00330     }
00331     
00332     if(lcd->mode == LANDSCAPE) {
00333         y0 = y0^x0;
00334         x0 = y0^x0;
00335         y0 = y0^x0;
00336         
00337         y1 = y1^x1;
00338         x1 = y1^x1;
00339         y1 = y1^x1;
00340         
00341         x0 = x0^x1;
00342         x1 = x0^x1;
00343         x0 = x0^x1;
00344         x0 = 239-x0;
00345         x1 = 239-x1;
00346     }
00347     
00348     //XL = constrain(XL, MIN_X, MAX_X);
00349     //x1 = constrain(x1, MIN_X, MAX_X);
00350     //y0 = constrain(y0, MIN_Y, MAX_Y);
00351     //y1 = constrain(y1, MIN_Y, MAX_Y);
00352 
00353     XY = (x1-x0+1);
00354     XY = XY*(y1-y0+1);
00355 
00356     lcd_setColumn(lcd, x0, x1);
00357     lcd_setPage(lcd, y0, y1);
00358     lcd_writeCommand(lcd, 0x2c); /* start to write to display ram */
00359    
00360     for(int i = 0; i < XY; i++)
00361     {
00362         lcd_writeData16(lcd, color);
00363     }
00364 }
00365 
00366 void lcd_fillSprite(lcd_t * lcd, int x0, int y0, int length, int width, short int *pColor) {    
00367     int XY=0;
00368     
00369     int x1 = x0+length;
00370     int y1 = y0+width;
00371     short int color;
00372     if(x0 > x1)
00373     {
00374         x0 = x0^x1;
00375         x1 = x0^x1;
00376         x0 = x0^x1;
00377     }
00378     
00379     if(y0 > y1)
00380     {
00381         y0 = y0^y1;
00382         y1 = y0^y1;
00383         y0 = y0^y1;
00384     }
00385     
00386     if(lcd->mode == LANDSCAPE) {
00387         y0 = y0^x0;
00388         x0 = y0^x0;
00389         y0 = y0^x0;
00390         
00391         y1 = y1^x1;
00392         x1 = y1^x1;
00393         y1 = y1^x1;
00394         
00395         x0 = x0^x1;
00396         x1 = x0^x1;
00397         x0 = x0^x1;
00398         x0 = 239-x0;
00399         x1 = 239-x1;
00400     }
00401     
00402     //XL = constrain(XL, MIN_X, MAX_X);
00403     //x1 = constrain(x1, MIN_X, MAX_X);
00404     //y0 = constrain(y0, MIN_Y, MAX_Y);
00405     //y1 = constrain(y1, MIN_Y, MAX_Y);
00406 
00407     XY = (x1-x0+1);
00408     XY = XY*(y1-y0+1);
00409 
00410     lcd_setColumn(lcd, x0, x1);
00411     lcd_setPage(lcd, y0, y1);
00412     lcd_writeCommand(lcd, 0x2c); /* start to write to display ram */
00413    
00414 #if 1 /* speed up */
00415     lcd_cd(lcd, 1);
00416     lcd_cs(lcd, 0);
00417     for(int i = 0; i < XY; i++)
00418     {
00419         color = *pColor++;
00420         spi_master_write(lcd->spi, (color >> 8));
00421         spi_master_write(lcd->spi, (color & 0xff));
00422     }
00423     lcd_cs(lcd, 1);
00424 #else
00425     for(int i = 0; i < XY; i++)
00426     {
00427         lcd_writeData16(lcd, *color++);
00428     }
00429 #endif
00430 }
00431 
00432 
00433 void lcd_drawTraingle(lcd_t * lcd, int x0, int y0, int x1, int y1, int x2, int y2, int color)
00434 {
00435     lcd_drawLine(lcd, x0, y0, x1, y1, color);
00436     lcd_drawLine(lcd, x0, y0, x2, y2, color);
00437     lcd_drawLine(lcd, x1, y1, x2, y2, color);
00438 }
00439 
00440 void lcd_fillTraingle(lcd_t * lcd, int x0, int y0, int x1, int y1, int x2, int y2, int color)
00441 {
00442     if(lcd->mode == LANDSCAPE) {
00443         y0 = y0^x0;
00444         x0 = y0^x0;
00445         y0 = y0^x0;
00446 
00447         y1 = y1^x1;
00448         x1 = y1^x1;
00449         y1 = y1^x1;
00450 
00451         y2 = y2^x2;
00452         x2 = y2^x2;
00453         y2 = y2^x2;
00454         
00455         x0 = 239-x0;
00456         x1 = 239-x1;
00457         x2 = 239-x2;
00458     }
00459     
00460     if(y0 > y1) {
00461         y0 = y0^y1;
00462         y1 = y0^y1;
00463         y0 = y0^y1;
00464         
00465         x0 = x0^x1;
00466         x1 = x0^x1;
00467         x0 = x0^x1;
00468     }
00469     
00470     if(y1 > y2) {
00471         y2 = y2^y1;
00472         y1 = y2^y1;
00473         y2 = y2^y1;
00474         
00475         x2 = x2^x1;
00476         x1 = x2^x1;
00477         x2 = x2^x1;
00478     }
00479     
00480     if(y0 > y1) {
00481         y0 = y0^y1;
00482         y1 = y0^y1;
00483         y0 = y0^y1;
00484         
00485         x0 = x0^x1;
00486         x1 = x0^x1;
00487         x0 = x0^x1;
00488     }
00489     
00490     if(x1 > x2) {
00491         x1 = x1^x2;
00492         x2 = x1^x2;
00493         x1 = x1^x2;
00494         
00495         y1 = y1^y2;
00496         y2 = y1^y2;
00497         y1 = y1^y2;
00498     }
00499 
00500     int xl = x0;
00501     int yl = y0;
00502     int xle = x1;
00503     int yle = y1;
00504     int dxl = abs(x1-x0), sxl = x0 < x1 ? 1 : -1;
00505     int dyl = -abs(y1-y0), syl = y0 < y1 ? 1 : -1;
00506     int errl = dxl + dyl, e2l;
00507 
00508     int xr = x0;
00509     int yr = y0;
00510     int xre = x2;
00511     int yre = y2;
00512     int dxr = abs(x2-x0), sxr = x0 < x2 ? 1 : -1;
00513     int dyr = -abs(y2-y0), syr = y0 < y2 ? 1 : -1;
00514     int errr = dxr + dyr, e2r;
00515 
00516     int xlp = xl;
00517     int xrp = xr;
00518 
00519     do {
00520         if(yl <= yr && (xl != xle || yl != yle)) {
00521             e2l = 2*errl;
00522             if (e2l >= dyl && xl != xle) {
00523                 errl += dyl; xl += sxl;
00524             }
00525 
00526             if (e2l <= dxl && yl != yle) {
00527                 errl += dxl; yl += syl;
00528 
00529                 if(yl == yr) {
00530                     //lcd_drawHorizontalLine(lcd, xlp, yl-1, xrp-xlp+1, color);
00531                     
00532                     lcd_setColumn(lcd, xlp, xrp);
00533                     lcd_setPage(lcd, yl-1, yl-1);
00534                     lcd_writeCommand(lcd, 0x2c);
00535                     for(int i=0; i < xrp-xlp; i++)
00536                         lcd_writeData16(lcd, color);
00537                     
00538                     xlp = xl;
00539                     xrp = xr;
00540                 }
00541             }else {
00542                 if(sxl < 0) {
00543                     xlp = xl;
00544                 }
00545             }
00546         }else if (yle < yre) {
00547             dxl = abs(xl-x2);
00548             sxl = xl < x2 ? 1 : -1;
00549             dyl = -abs(yl-y2);
00550             syl = 1;
00551             xle = x2;
00552             yle = y2;
00553             errl = dxl + dyl;
00554         }
00555 
00556         if(yr <= yl && (xr != xre || yr != yre)) {
00557             e2r = 2*errr;
00558             if (e2r >= dyr && xr != xre) {
00559                 errr += dyr; xr += sxr;
00560             }
00561 
00562             if (e2r <= dxr && yr != yre) {
00563                 errr += dxr; yr += syr;
00564 
00565                 if(yl==yr) {
00566                     //lcd_drawHorizontalLine(lcd, xlp, yl-1, xrp-xlp+1, color);
00567                         
00568                     lcd_setColumn(lcd, xlp, xrp);
00569                     lcd_setPage(lcd, yl-1, yl-1);
00570                     lcd_writeCommand(lcd, 0x2c);
00571                     for(int i=0; i < xrp-xlp; i++)
00572                         lcd_writeData16(lcd, color);
00573                     
00574                     xlp = xl;
00575                     xrp = xr;
00576                 }
00577             }else {
00578                 if(sxr > 0) {
00579                     xrp = xr;
00580                 }
00581             }
00582 
00583         }else if (yre < yle) {
00584             dxr = abs(xr-x1);
00585             dyr = -abs(yr-y1);
00586             sxr = xr < x1 ? 1 : -1;
00587             syr = 1;
00588             xre = x1;
00589             yre = y1;
00590             errr = dxr + dyr;
00591         }
00592     }while ((xl < xle || yl < yle || xr < xre || yr < yre));
00593 
00594     lcd_setColumn(lcd, xlp, xrp);
00595     lcd_setPage(lcd, yl, yl);
00596     lcd_writeCommand(lcd, 0x2c);
00597     for(int i=0; i < xrp-xlp; i++)
00598         lcd_writeData16(lcd, color);
00599 }
00600 
00601 void lcd_drawCircle(lcd_t * lcd, int x, int y, int radius, int color)
00602 {
00603     if(lcd->mode==LANDSCAPE) {
00604         y=x^y;
00605         x=x^y;
00606         y=x^y;
00607         x=239-x;
00608     }
00609 
00610     int dx = -radius, dy = 0, err = 2-2*radius, e2;
00611     do {
00612         lcd_setPixel(lcd, x-dx, y+dy, color);
00613         lcd_setPixel(lcd, x+dx, y+dy, color);
00614         lcd_setPixel(lcd, x+dx, y-dy, color);
00615         lcd_setPixel(lcd, x-dx, y-dy, color);
00616         e2 = err;
00617         if (e2 <= dy) {
00618             err += ++dy*2+1;
00619             if (-dx == dy && e2 <= dx) e2 = 0;
00620         }
00621         if (e2 > dx) err += ++dx*2+1;
00622     } while (dx <= 0);
00623 }
00624 
00625 void lcd_drawChar(lcd_t * lcd, char c, int x, int y, uint16_t size, uint16_t color)
00626 {
00627     if(!(c >= 32) && (c <= 127)) {
00628         c = '?'-32;
00629     }
00630     
00631     for (int i =0; i < FONT_X; i++ ) {
00632         uint8_t temp = simpleFont[c-32][i];
00633         for(uint8_t f = 0; f < 8; f++) {
00634             if((temp>>f)&0x01) {
00635                 lcd_fillRectangle(lcd, x+i*size, y+f*size, size, size, color);
00636                 }
00637 #if 1 /* Hintergrund ebenfalls setzen */
00638             else{
00639                 lcd_fillRectangle(lcd, x+i*size, y+f*size, size, size, WHITE);
00640                 }
00641 #endif
00642         }
00643     }
00644 }
00645 
00646 void lcd_drawString(lcd_t * lcd, char * ca, int x, int y, uint16_t size, uint16_t color)
00647 {
00648     while(*ca) {
00649         lcd_drawChar(lcd, *ca, x, y, size, color);
00650         *ca++;
00651 
00652         if(x < MAX_X) {
00653             x += FONT_SPACE*size; /* Move cursor right */
00654         }
00655     }
00656 }
00657 
00658 uint8_t lcd_drawNumber(lcd_t * lcd, long long_num, int x, int y, uint16_t size, uint16_t color)
00659 {
00660     uint8_t char_buffer[10] = "";
00661     uint8_t i = 0;
00662     uint8_t f = 0;
00663 
00664     if(long_num < 0) {
00665         f = 1;
00666         lcd_drawChar(lcd, '-', x, y, size, color);
00667         long_num = -long_num;
00668         
00669         if(x < MAX_X) {
00670             x += FONT_SPACE*size; /* Move cursor right */
00671         }
00672     }else if(long_num == 0) {
00673         f = 1;
00674         lcd_drawChar(lcd, '0', x, y, size, color);
00675         return f; //<-- Bullshit -->
00676         
00677         //if(x < MAX_X) {
00678         //    x += FONT_SPACE*size; /* Move cursor right */
00679         //}
00680     }
00681 
00682     while (long_num > 0) {
00683         char_buffer[i++] = long_num % 10;
00684         long_num /= 10;
00685     }
00686 
00687     f = f+i;
00688     
00689     for(; i > 0; i--) {
00690         lcd_drawChar(lcd, '0' + char_buffer[i - 1], x, y, size, color);
00691         
00692         if(x < MAX_X) {
00693             x += FONT_SPACE*size; /* Move cursor right */
00694         }
00695     }
00696     
00697     return f;
00698 }
00699 
00700 uint8_t lcd_drawFloat(lcd_t * lcd, float floatNumber, uint8_t decimal, int x, int y, uint16_t size, uint16_t color)
00701 {
00702     uint16_t temp = 0;
00703     float decy = 0.0;
00704     float rounding = 0.5;
00705     uint8_t f = 0;
00706     
00707     if(floatNumber < 0.0)
00708     {
00709         lcd_drawChar(lcd, '-', x, y, size, color);
00710         floatNumber = -floatNumber;
00711         if(x < MAX_X)
00712         {
00713             x += FONT_SPACE * size;                                       /* Move cursor right            */
00714         }
00715         f = 1;
00716     }
00717     
00718     for(uint8_t i = 0; i < decimal; ++i)
00719     {
00720         rounding /= 10.0;
00721     }
00722     floatNumber += rounding;
00723 
00724     temp = (uint16_t)floatNumber;
00725     uint8_t howlong = lcd_drawNumber(lcd, temp, x, y, size, color);
00726     f += howlong;
00727     
00728     if((x+8*size*howlong) < MAX_X)
00729     {
00730         x += FONT_SPACE * size * howlong;                                   /* Move cursor right            */
00731     }
00732 
00733     if(decimal > 0)
00734     {
00735         lcd_drawChar(lcd, '.', x, y, size, color);
00736         if(x < MAX_X)
00737         {
00738             x += FONT_SPACE * size;                                       /* Move cursor right            */
00739         }
00740         f += 1;
00741     }
00742     
00743     decy = floatNumber - temp;
00744                                             /* decimal part,  4             */
00745     for(uint8_t i = 0; i < decimal; i++)                                      
00746     {
00747         decy *= 10;                                                      /* for the next decimal         */
00748         temp = decy;                                                    /* get the decimal              */
00749         lcd_drawNumber(lcd, temp, x, y, size, color);
00750         floatNumber = -floatNumber;
00751         
00752         if(x < MAX_X)
00753         {
00754             x += FONT_SPACE * size;                                       /* Move cursor right            */
00755         }
00756         
00757         decy -= temp;
00758     }
00759     
00760     f += decimal;
00761     return f;
00762 }