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