Printit.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  Modified 03 August 2015 by Chuck Todd
00021  */
00022 
00023 //#include <stdlib.h>
00024 //#include <stdio.h>
00025 //#include <string.h>
00026 #include <math.h>
00027 //#include "Arduino.h"
00028 
00029 #include "Printit.h"
00030 
00031 // Public Methods //////////////////////////////////////////////////////////////
00032 
00033 /* default implementation: may be overridden */
00034 size_t Print::write(const uint8_t *buffer, size_t size)
00035 {
00036     size_t n = 0;
00037     while (size--) {
00038         if (write(*buffer++)) n++;
00039         else break;
00040     }
00041     return n;
00042 }
00043 
00044 #if 0
00045 size_t Print::print(const __FlashStringHelper *ifsh)
00046 {
00047     PGM_P p = reinterpret_cast<PGM_P>(ifsh);
00048     size_t n = 0;
00049     while (1) {
00050         unsigned char c = pgm_read_byte(p++);
00051         if (c == 0) break;
00052         if (write(c)) n++;
00053         else break;
00054     }
00055     return n;
00056 }
00057 
00058 size_t Print::print(const String &s)
00059 {
00060     return write(s.c_str(), s.length());
00061 }
00062 #endif
00063 
00064 size_t Print::print(char *str)
00065 {
00066     return write(str);
00067 }
00068 
00069 size_t Print::print(char c)
00070 {
00071     return write(c);
00072 }
00073 
00074 size_t Print::print(unsigned char b, int base)
00075 {
00076     return print((unsigned long) b, base);
00077 }
00078 
00079 size_t Print::print(int n, int base)
00080 {
00081     return print((long) n, base);
00082 }
00083 
00084 size_t Print::print(unsigned int n, int base)
00085 {
00086     return print((unsigned long) n, base);
00087 }
00088 
00089 size_t Print::print(long n, int base)
00090 {
00091     if (base == 0) {
00092         return write(n);
00093     } else if (base == 10) {
00094         if (n < 0) {
00095             int t = print('-');
00096             n = -n;
00097             return printNumber(n, 10) + t;
00098         }
00099         return printNumber(n, 10);
00100     } else {
00101         return printNumber(n, base);
00102     }
00103 }
00104 
00105 size_t Print::print(unsigned long n, int base)
00106 {
00107     if (base == 0) return write(n);
00108     else return printNumber(n, base);
00109 }
00110 
00111 size_t Print::print(double n, int digits)
00112 {
00113     return printFloat(n, digits);
00114 }
00115 
00116 #if 0
00117 size_t Print::println(const __FlashStringHelper *ifsh)
00118 {
00119     size_t n = print(ifsh);
00120     n += println();
00121     return n;
00122 }
00123 #endif
00124 
00125 size_t Print::print(const Printable& x)
00126 {
00127     return x.printTo(*this);
00128 }
00129 
00130 size_t Print::println(void)
00131 {
00132     return write("\r\n");
00133 }
00134 
00135 #if 0
00136 size_t Print::println(const String &s)
00137 {
00138     size_t n = print(s);
00139     n += println();
00140     return n;
00141 }
00142 #endif
00143 
00144 size_t Print::println(char *c)
00145 {
00146     size_t n = print(c);
00147     n += println();
00148     return n;
00149 }
00150 
00151 size_t Print::println(char c)
00152 {
00153     size_t n = print(c);
00154     n += println();
00155     return n;
00156 }
00157 
00158 size_t Print::println(unsigned char b, int base)
00159 {
00160     size_t n = print(b, base);
00161     n += println();
00162     return n;
00163 }
00164 
00165 size_t Print::println(int num, int base)
00166 {
00167     size_t n = print(num, base);
00168     n += println();
00169     return n;
00170 }
00171 
00172 size_t Print::println(unsigned int num, int base)
00173 {
00174     size_t n = print(num, base);
00175     n += println();
00176     return n;
00177 }
00178 
00179 size_t Print::println(long num, int base)
00180 {
00181     size_t n = print(num, base);
00182     n += println();
00183     return n;
00184 }
00185 
00186 size_t Print::println(unsigned long num, int base)
00187 {
00188     size_t n = print(num, base);
00189     n += println();
00190     return n;
00191 }
00192 
00193 size_t Print::println(double num, int digits)
00194 {
00195     size_t n = print(num, digits);
00196     n += println();
00197     return n;
00198 }
00199 
00200 size_t Print::println(const Printable& x)
00201 {
00202     size_t n = print(x);
00203     n += println();
00204     return n;
00205 }
00206 
00207 // Private Methods /////////////////////////////////////////////////////////////
00208 
00209 size_t Print::printNumber(unsigned long n, uint8_t base)
00210 {
00211     char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
00212     char *str = &buf[sizeof(buf) - 1];
00213 
00214     *str = '\0';
00215 
00216     // prevent crash if called with base == 1
00217     if (base < 2) base = 10;
00218 
00219     do {
00220         char c = n % base;
00221         n /= base;
00222 
00223         *--str = c < 10 ? c + '0' : c + 'A' - 10;
00224     } while(n);
00225 
00226     return write(str);
00227 }
00228 
00229 size_t Print::printFloat(double number, uint8_t digits)
00230 {
00231     size_t n = 0;
00232 
00233     if (isnan(number)) return print("nan");
00234     if (isinf(number)) return print("inf");
00235     if (number > 4294967040.0) return print ("ovf");  // constant determined empirically
00236     if (number <-4294967040.0) return print ("ovf");  // constant determined empirically
00237 
00238     // Handle negative numbers
00239     if (number < 0.0) {
00240         n += print('-');
00241         number = -number;
00242     }
00243 
00244     // Round correctly so that print(1.999, 2) prints as "2.00"
00245     double rounding = 0.5;
00246     for (uint8_t i=0; i<digits; ++i)
00247         rounding /= 10.0;
00248 
00249     number += rounding;
00250 
00251     // Extract the integer part of the number and print it
00252     unsigned long int_part = (unsigned long)number;
00253     double remainder = number - (double)int_part;
00254     n += print(int_part);
00255 
00256     // Print the decimal point, but only if there are digits beyond
00257     if (digits > 0) {
00258         n += print(".");
00259     }
00260 
00261     // Extract digits from the remainder one at a time
00262     while (digits-- > 0) {
00263         remainder *= 10.0;
00264         int toPrint = int(remainder);
00265         n += print(toPrint);
00266         remainder -= toPrint;
00267     }
00268 
00269     return n;
00270 }
00271