Print.cpp

00001 /*
00002  Print.cpp - Base class that provides print() and println()
00003  Copyright (c) 2008 David A. Mellis.  All right reserved.
00004  
00005  This library is free software; you can redistribute it and/or
00006  modify it under the terms of the GNU Lesser General Public
00007  License as published by the Free Software Foundation; either
00008  version 2.1 of the License, or (at your option) any later version.
00009  
00010  This library is distributed in the hope that it will be useful,
00011  but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013  Lesser General Public License for more details.
00014  
00015  You should have received a copy of the GNU Lesser General Public
00016  License along with this library; if not, write to the Free Software
00017  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
00018  
00019  Modified 23 November 2006 by David A. Mellis
00020  */
00021 
00022 #include <stdlib.h>
00023 #include <stdio.h>
00024 #include <string.h>
00025 #include <math.h>
00026 
00027 #include "Print.h"
00028 
00029 // Public Methods //////////////////////////////////////////////////////////////
00030 
00031 /* default implementation: may be overridden */
00032 size_t Print::write(const uint8_t *buffer, size_t size)
00033 {
00034   size_t n = 0;
00035   while (size--) {
00036     n += write(*buffer++);
00037   }
00038   return n;
00039 }
00040 
00041 
00042 size_t Print::print(const String &s)
00043 {
00044   size_t n = 0;
00045   for (uint16_t i = 0; i < s.length(); i++) {
00046     n += write(s[i]);
00047   }
00048   return n;
00049 }
00050 
00051 size_t Print::print(const char str[])
00052 {
00053   return write(str);
00054 }
00055 
00056 size_t Print::print(char c)
00057 {
00058   return write(c);
00059 }
00060 
00061 size_t Print::print(unsigned char b, int base)
00062 {
00063   return print((unsigned long) b, base);
00064 }
00065 
00066 size_t Print::print(int n, int base)
00067 {
00068   return print((long) n, base);
00069 }
00070 
00071 size_t Print::print(unsigned int n, int base)
00072 {
00073   return print((unsigned long) n, base);
00074 }
00075 
00076 size_t Print::print(long n, int base)
00077 {
00078   if (base == 0) {
00079     return write(n);
00080   } else if (base == 10) {
00081     if (n < 0) {
00082       int t = print('-');
00083       n = -n;
00084       return printNumber(n, 10) + t;
00085     }
00086     return printNumber(n, 10);
00087   } else {
00088     return printNumber(n, base);
00089   }
00090 }
00091 
00092 size_t Print::print(unsigned long n, int base)
00093 {
00094   if (base == 0) return write(n);
00095   else return printNumber(n, base);
00096 }
00097 
00098 size_t Print::print(double n, int digits)
00099 {
00100   return printFloat(n, digits);
00101 }
00102 
00103 size_t Print::println(void)
00104 {
00105   size_t n = print('\r');
00106   n += print('\n');
00107   return n;
00108 }
00109 
00110 size_t Print::println(const String &s)
00111 {
00112   size_t n = print(s);
00113   n += println();
00114   return n;
00115 }
00116 
00117 size_t Print::println(const char c[])
00118 {
00119   size_t n = print(c);
00120   n += println();
00121   return n;
00122 }
00123 
00124 size_t Print::println(char c)
00125 {
00126   size_t n = print(c);
00127   n += println();
00128   return n;
00129 }
00130 
00131 size_t Print::println(unsigned char b, int base)
00132 {
00133   size_t n = print(b, base);
00134   n += println();
00135   return n;
00136 }
00137 
00138 size_t Print::println(int num, int base)
00139 {
00140   size_t n = print(num, base);
00141   n += println();
00142   return n;
00143 }
00144 
00145 size_t Print::println(unsigned int num, int base)
00146 {
00147   size_t n = print(num, base);
00148   n += println();
00149   return n;
00150 }
00151 
00152 size_t Print::println(long num, int base)
00153 {
00154   size_t n = print(num, base);
00155   n += println();
00156   return n;
00157 }
00158 
00159 size_t Print::println(unsigned long num, int base)
00160 {
00161   size_t n = print(num, base);
00162   n += println();
00163   return n;
00164 }
00165 
00166 size_t Print::println(double num, int digits)
00167 {
00168   size_t n = print(num, digits);
00169   n += println();
00170   return n;
00171 }
00172 
00173 // Private Methods /////////////////////////////////////////////////////////////
00174 
00175 size_t Print::printNumber(unsigned long n, uint8_t base) {
00176   char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
00177   char *str = &buf[sizeof(buf) - 1];
00178 
00179   *str = '\0';
00180 
00181   // prevent crash if called with base == 1
00182   if (base < 2) base = 10;
00183 
00184   do {
00185     unsigned long m = n;
00186     n /= base;
00187     char c = m - base * n;
00188     *--str = c < 10 ? c + '0' : c + 'A' - 10;
00189   } while(n);
00190 
00191   return write(str);
00192 }
00193 
00194 size_t Print::printFloat(double number, uint8_t digits) 
00195 { 
00196   size_t n = 0;
00197   
00198   if (isnan(number)) return print("nan");
00199   if (isinf(number)) return print("inf");
00200   if (number > 4294967040.0) return print ("ovf");  // constant determined empirically
00201   if (number <-4294967040.0) return print ("ovf");  // constant determined empirically
00202   
00203   // Handle negative numbers
00204   if (number < 0.0)
00205   {
00206      n += print('-');
00207      number = -number;
00208   }
00209 
00210   // Round correctly so that print(1.999, 2) prints as "2.00"
00211   double rounding = 0.5;
00212   for (uint8_t i=0; i<digits; ++i)
00213     rounding /= 10.0;
00214   
00215   number += rounding;
00216 
00217   // Extract the integer part of the number and print it
00218   unsigned long int_part = (unsigned long)number;
00219   double remainder = number - (double)int_part;
00220   n += print(int_part);
00221 
00222   // Print the decimal point, but only if there are digits beyond
00223   if (digits > 0) {
00224     n += print("."); 
00225   }
00226 
00227   // Extract digits from the remainder one at a time
00228   while (digits-- > 0)
00229   {
00230     remainder *= 10.0;
00231     int toPrint = int(remainder);
00232     n += print(toPrint);
00233     remainder -= toPrint; 
00234   } 
00235   
00236   return n;
00237 }