DigoleSerialDisp.cpp

00001 /** Digole Serial Display library
00002  *
00003  * @Author: Digole Digital Solutions : www.digole.com ported to mbed by Michael Shimniok www.bot-thoughts.com
00004  */
00005  
00006 #include "mbed.h"
00007 #include "DigoleSerialDisp.h"
00008 #include <stdio.h>
00009 #include <string.h>
00010 #include <inttypes.h>
00011 
00012 char null = 0;
00013 
00014 
00015 // that resetting the Arduino doesn't reset the LCD, so we
00016 // can't assume that its in that state when a sketch starts (and the
00017 // LiquidCrystal constructor is called).
00018 
00019 //UART function
00020 
00021 char buf[128];
00022 char tmp[128];
00023 
00024 DigoleSerialDisp::DigoleSerialDisp(PinName sda, PinName scl, uint8_t address):
00025     _device(sda, scl)
00026 {
00027     _address = (address<<1);
00028     _device.frequency(300000);
00029     _Comdelay=70;//70;
00030 }
00031 
00032 size_t DigoleSerialDisp::write(const char x)
00033 {
00034     _device.write(_address, (char *) &x, 1);
00035 
00036     return 1;
00037 }
00038 
00039 size_t DigoleSerialDisp::write(const char *str) 
00040 {
00041     if (str == NULL) return 0;
00042     return write(str, strlen(str));
00043 }
00044     
00045 size_t DigoleSerialDisp::write(const char *buffer, size_t size)
00046 {
00047     int len = 0;
00048     if (buffer != NULL) {
00049         len = _device.write(_address, (char *) buffer, size);
00050         if (len == 0){
00051             len = size;
00052         }else{
00053             len = -1;
00054         }
00055         delay(7);
00056     }
00057     return len;
00058 }
00059 
00060 
00061 size_t DigoleSerialDisp::print(const char c)
00062 {
00063     buf[0] = 'T';
00064     buf[1] = 'T';
00065     buf[2] = c;
00066     buf[3] = 0;
00067     write(buf);
00068     write(null);
00069     return 1;
00070 }
00071 
00072 size_t DigoleSerialDisp::print(const char s[])
00073 {
00074     int len = strlen(s);
00075 
00076     if (s == NULL) return 0;
00077 
00078     buf[0] = 'T';
00079     buf[1] = 'T';
00080     buf[2] = 0;
00081     strncat(buf, s, 125);
00082     write(buf);
00083     write(null);
00084     return len;
00085 }
00086 
00087 size_t DigoleSerialDisp::println(const char s[])
00088 {
00089     return print(s);
00090 }
00091 
00092 /*
00093  Print.cpp - Base class that provides print() and println()
00094  Copyright (c) 2008 David A. Mellis.  All right reserved.
00095  
00096  This library is free software; you can redistribute it and/or
00097  modify it under the terms of the GNU Lesser General Public
00098  License as published by the Free Software Foundation; either
00099  version 2.1 of the License, or (at your option) any later version.
00100  
00101  This library is distributed in the hope that it will be useful,
00102  but WITHOUT ANY WARRANTY; without even the implied warranty of
00103  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00104  Lesser General Public License for more details.
00105  
00106  You should have received a copy of the GNU Lesser General Public
00107  License along with this library; if not, write to the Free Software
00108  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
00109  
00110  Modified 23 November 2006 by David A. Mellis
00111  */
00112 
00113 size_t DigoleSerialDisp::print(unsigned char b, int base)
00114 {
00115   return print((unsigned long) b, base);
00116 }
00117 
00118 size_t DigoleSerialDisp::print(int n, int base)
00119 {
00120   return print((long) n, base);
00121 }
00122 
00123 size_t DigoleSerialDisp::print(unsigned int n, int base)
00124 {
00125   return print((unsigned long) n, base);
00126 }
00127 
00128 size_t DigoleSerialDisp::print(long n, int base)
00129 {
00130   if (base == 0) {
00131     return write(n);
00132   } else if (base == 10) {
00133     if (n < 0) {
00134       int t = print('-');
00135       n = -n;
00136       return printNumber(n, 10) + t;
00137     }
00138     return printNumber(n, 10);
00139   } else {
00140     return printNumber(n, base);
00141   }
00142 }
00143 
00144 size_t DigoleSerialDisp::print(unsigned long n, int base)
00145 {
00146   if (base == 0) return write(n);
00147   else return printNumber(n, base);
00148 }
00149 
00150 size_t DigoleSerialDisp::print(double n, int digits)
00151 {
00152   return printFloat(n, digits);
00153 }
00154 
00155 size_t DigoleSerialDisp::println(unsigned char b, int base)
00156 {
00157   size_t n = print(b, base);
00158   n += println();
00159   return n;
00160 }
00161 
00162 size_t DigoleSerialDisp::println(int num, int base)
00163 {
00164   size_t n = print(num, base);
00165   n += println();
00166   return n;
00167 }
00168 
00169 size_t DigoleSerialDisp::println(unsigned int num, int base)
00170 {
00171   size_t n = print(num, base);
00172   n += println();
00173   return n;
00174 }
00175 
00176 size_t DigoleSerialDisp::println(long num, int base)
00177 {
00178   size_t n = print(num, base);
00179   n += println();
00180   return n;
00181 }
00182 
00183 size_t DigoleSerialDisp::println(unsigned long num, int base)
00184 {
00185   size_t n = print(num, base);
00186   n += println();
00187   return n;
00188 }
00189 
00190 size_t DigoleSerialDisp::println(double num, int digits)
00191 {
00192   size_t n = print(num, digits);
00193   n += println();
00194   return n;
00195 }
00196 
00197 size_t DigoleSerialDisp::println(void) 
00198 {
00199     return 1;
00200 }
00201 
00202 // Private Methods /////////////////////////////////////////////////////////////
00203 
00204 size_t DigoleSerialDisp::printNumber(unsigned long n, uint8_t base) {
00205   char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
00206   char *str = &buf[sizeof(buf) - 1];
00207 
00208   *str = '\0';
00209 
00210   // prevent crash if called with base == 1
00211   if (base < 2) base = 10;
00212 
00213   do {
00214     unsigned long m = n;
00215     n /= base;
00216     char c = m - base * n;
00217     *--str = c < 10 ? c + '0' : c + 'A' - 10;
00218   } while(n);
00219 
00220   return write(str);
00221 }
00222 
00223 size_t DigoleSerialDisp::printFloat(double number, uint8_t digits) 
00224 { 
00225   size_t n = 0;
00226   
00227   if (isnan(number)) return print("nan");
00228   if (isinf(number)) return print("inf");
00229   if (number > 4294967040.0) return print ("ovf");  // constant determined empirically
00230   if (number <-4294967040.0) return print ("ovf");  // constant determined empirically
00231   
00232   // Handle negative numbers
00233   if (number < 0.0)
00234   {
00235      n += print('-');
00236      number = -number;
00237   }
00238 
00239   // Round correctly so that print(1.999, 2) prints as "2.00"
00240   double rounding = 0.5;
00241   for (uint8_t i=0; i<digits; ++i)
00242     rounding /= 10.0;
00243   
00244   number += rounding;
00245 
00246   // Extract the integer part of the number and print it
00247   unsigned long int_part = (unsigned long)number;
00248   double remainder = number - (double)int_part;
00249   n += print(int_part);
00250 
00251   // Print the decimal point, but only if there are digits beyond
00252   if (digits > 0) {
00253     n += print("."); 
00254   }
00255 
00256   // Extract digits from the remainder one at a time
00257   while (digits-- > 0)
00258   {
00259     remainder *= 10.0;
00260     int toPrint = int(remainder);
00261     n += print(toPrint);
00262     remainder -= toPrint; 
00263   } 
00264   
00265   return n;
00266 }
00267 
00268 /*---------functions for Text and Graphic LCD adapters---------*/
00269 void DigoleSerialDisp::disableCursor(void) 
00270 {
00271     write("CS");
00272     write(null);
00273 }
00274 
00275 void DigoleSerialDisp::enableCursor(void) 
00276 {
00277     write("CS");
00278     write(1);
00279 }
00280 
00281 void DigoleSerialDisp::drawStr(uint8_t x, uint8_t y, const char *s) 
00282 {
00283     write("TP");
00284     write(x);
00285     write(y);
00286     write("TT");
00287     write(s);
00288     write(null);
00289 }
00290 
00291 void DigoleSerialDisp::setPrintPos(uint8_t x, uint8_t y, uint8_t graph) 
00292 {
00293     if (graph == _TEXT_) {
00294         write("TP");
00295         write(x);
00296         write(y);
00297     } else {
00298         write("GP");
00299         write(x);
00300         write(y);
00301     }
00302 }
00303 
00304 void DigoleSerialDisp::clearScreen(void) 
00305 {
00306     //write(null);
00307     write("CL");
00308 }
00309 
00310 
00311 void DigoleSerialDisp::setLCDColRow(uint8_t col, uint8_t row) 
00312 {
00313     write("STCR");
00314     write(col);
00315     write(row);
00316     write("\x80\xC0\x94\xD4");
00317 }
00318 
00319 void DigoleSerialDisp::setI2CAddress(uint8_t add) 
00320 {
00321     write("SI2CA");
00322     write(add);
00323     _address = (add<<1);
00324 }
00325 
00326 void DigoleSerialDisp::displayConfig(uint8_t v) 
00327 {
00328     write("DC");
00329     write(v);
00330 }
00331 
00332 void DigoleSerialDisp::preprint(void) 
00333 {
00334     //print("TT");
00335 }
00336 
00337 /*----------Functions for Graphic LCD/OLED adapters only---------*/
00338 void DigoleSerialDisp::drawBitmap(uint8_t x, uint8_t y, uint8_t w, uint8_t h, const uint8_t *bitmap) {
00339     uint8_t i = 0;
00340     if ((w & 7) != 0)
00341         i = 1;
00342     write("DIM");
00343     write(x); //x;
00344     write(y);
00345     write(w);
00346     write(h);
00347     for (int j = 0; j < h * ((w >> 3) + i); j++) {
00348         write( bitmap[j] );
00349         delay(1);
00350     }
00351 }
00352 
00353 void DigoleSerialDisp::drawBitmap256(uint8_t x, uint8_t y, uint8_t w, uint8_t h, const uint8_t *bitmap) {
00354     write("EDIM1");
00355     write(x); //x;
00356     write(y);
00357     write(w);
00358     write(h);
00359     for (int j = 0; j < h * w; j++) {
00360         write(bitmap[j]);
00361         delay(1);
00362     }
00363 }
00364 
00365 void DigoleSerialDisp::setRot90(void) {
00366     write("SD1");
00367 }
00368 
00369 void DigoleSerialDisp::setRot180(void) {
00370     write("SD2");
00371 }
00372 
00373 void DigoleSerialDisp::setRot270(void) {
00374     write("SD3");
00375 }
00376 
00377 void DigoleSerialDisp::undoRotation(void) {
00378     write("SD0");
00379 }
00380 
00381 void DigoleSerialDisp::setRotation(uint8_t d) {
00382     write("SD");
00383     write(d);
00384 }
00385 
00386 void DigoleSerialDisp::setContrast(uint8_t c) {
00387     write("CT");
00388     write(c);
00389 }
00390 
00391 void DigoleSerialDisp::drawBox(uint8_t x, uint8_t y, uint8_t w, uint8_t h) {
00392     write("FR");
00393     write(x);
00394     write(y);
00395     write(x + w);
00396     write(y + h);
00397 }
00398 
00399 void DigoleSerialDisp::drawCircle(uint8_t x, uint8_t y, uint8_t r, uint8_t f) {
00400     write("CC");
00401     write(x);
00402     write(y);
00403     write(r);
00404     write(f);
00405 }
00406 
00407 void DigoleSerialDisp::drawDisc(uint8_t x, uint8_t y, uint8_t r) {
00408     drawCircle(x, y, r, 1);
00409 }
00410 
00411 void DigoleSerialDisp::drawFrame(uint8_t x, uint8_t y, uint8_t w, uint8_t h) {
00412     write("DR");
00413     write(x);
00414     write(y);
00415     write(x + w);
00416     write(y + h);
00417 }
00418 
00419 void DigoleSerialDisp::drawPixel(uint8_t x, uint8_t y, uint8_t color) {
00420     write("DP");
00421     write(x);
00422     write(y);
00423     write(color);
00424 }
00425 
00426 void DigoleSerialDisp::drawLine(uint8_t x, uint8_t y, uint8_t x1, uint8_t y1) {
00427     write("LN");
00428     write(x);
00429     write(y);
00430     write(x1);
00431     write(y1);
00432 }
00433 
00434 void DigoleSerialDisp::drawLineTo(uint8_t x, uint8_t y) {
00435     write("LT");
00436     write(x);
00437     write(y);
00438 }
00439 
00440 void DigoleSerialDisp::drawHLine(uint8_t x, uint8_t y, uint8_t w) {
00441     drawLine(x, y, x + w, y);
00442 }
00443 
00444 void DigoleSerialDisp::drawVLine(uint8_t x, uint8_t y, uint8_t h) {
00445     drawLine(x, y, x, y + h);
00446 }
00447 
00448 void DigoleSerialDisp::nextTextLine(void) {
00449     write(null);
00450     write("TRT");
00451 }
00452 
00453 void DigoleSerialDisp::setFont(uint8_t font) {
00454     write("SF");
00455     write(font);
00456 }
00457 
00458 void DigoleSerialDisp::setColor(uint8_t color) {
00459     write("SC");
00460     write(color);
00461 }
00462 
00463 void DigoleSerialDisp::setBgColor(uint8_t color) {
00464     write("BGC");
00465     write(color);
00466 }
00467 
00468 void DigoleSerialDisp::backLightOn(void) {
00469     write("BL");
00470     write(1);
00471 }
00472 
00473 void DigoleSerialDisp::backLightOff(void) {
00474     write("BL");
00475     write(null);
00476 }
00477 
00478 void DigoleSerialDisp::directCommand(uint8_t d) {
00479     write("MCD");
00480     write(d);
00481 }
00482 
00483 void DigoleSerialDisp::directData(uint8_t d) {
00484     write("MDT");
00485     write(d);
00486 }
00487 
00488 void DigoleSerialDisp::moveArea(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1, char xoffset, char yoffset) {
00489     write("MA");
00490     write(x0);
00491     write(y0);
00492     write(x1);
00493     write(y1);
00494     write(xoffset);
00495     write(yoffset);
00496 }
00497 
00498 
00499 int DigoleSerialDisp::displayStartScreen(uint8_t m) {
00500     int ret =0;
00501     ret = write("DSS");
00502     if (ret == -1) return -1;
00503     write(m);
00504     return 0;
00505 } //display start screen
00506 
00507 
00508 void DigoleSerialDisp::setMode(uint8_t m) {
00509     write("DM");
00510     write(m);
00511 } //set display mode
00512 
00513 
00514 void DigoleSerialDisp::setTextPosBack(void) {
00515     write("ETB");
00516 } //set text position back to previous, only one back allowed
00517 
00518 
00519 void DigoleSerialDisp::setTextPosOffset(char xoffset, char yoffset) {
00520     write("ETO");
00521     write(xoffset);
00522     write(yoffset);
00523 }
00524 
00525 
00526 void DigoleSerialDisp::setTextPosAbs(uint8_t x, uint8_t y) {
00527     write("ETP");
00528     write(x);
00529     write(y);
00530 }
00531 
00532 
00533 void DigoleSerialDisp::setLinePattern(uint8_t pattern) {
00534     write("SLP");
00535     write(pattern);
00536 }
00537 
00538 
00539 void DigoleSerialDisp::setLCDChip(uint8_t chip) {      //only for universal LCD adapter
00540     write("SLCD");
00541     write(chip);
00542 }
00543 
00544 
00545 void DigoleSerialDisp::setDrawWindow(uint16_t x, uint16_t y, uint16_t w, uint16_t h) {      
00546     write("DWWIN");
00547     write(x);
00548     write(y);
00549     write(w);
00550     write(h);
00551 }
00552 
00553 void DigoleSerialDisp::resetDrawWindow() {      
00554     write("RSTDW");
00555 }
00556 
00557 void DigoleSerialDisp::cleanDrawWindow() {      
00558     write("WINC");
00559 }
00560 
00561 
00562 
00563 void DigoleSerialDisp::uploadStartScreen(int lon, const unsigned char *data) 
00564 {
00565     int j;
00566     uint8_t c;
00567     write("SSS");
00568     write((uint8_t) (lon % 256));
00569     write((uint8_t) (lon / 256));
00570     for (j = 0; j < lon;j++) {
00571         if((j%32)==0)
00572             delay(10);
00573         delay(_Comdelay);
00574         c = data[j];
00575         write(c);
00576     }
00577 }
00578 
00579 
00580 void DigoleSerialDisp::uploadUserFont(int lon, const unsigned char *data, uint8_t sect) {
00581     uint8_t c;
00582     write("SUF");
00583     write(sect);
00584     write((uint8_t) (lon % 256));
00585     write((uint8_t) (lon / 256));
00586     for (int j = 0; j < lon; j++) {
00587         if((j%32)==0)
00588             delay(10);
00589         delay(_Comdelay);
00590         c = data[j];
00591         write(c);
00592     }
00593 }
00594 
00595 void DigoleSerialDisp::digitalOutput(uint8_t x) 
00596 {
00597     write("DOUT");
00598     write(x);
00599 }