1 | /*
|
---|
2 | Print.cpp - Base class that provides print() and println()
|
---|
3 | Copyright (c) 2008 David A. Mellis. All right reserved.
|
---|
4 |
|
---|
5 | This library is free software; you can redistribute it and/or
|
---|
6 | modify it under the terms of the GNU Lesser General Public
|
---|
7 | License as published by the Free Software Foundation; either
|
---|
8 | version 2.1 of the License, or (at your option) any later version.
|
---|
9 |
|
---|
10 | This library is distributed in the hope that it will be useful,
|
---|
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
13 | Lesser General Public License for more details.
|
---|
14 |
|
---|
15 | You should have received a copy of the GNU Lesser General Public
|
---|
16 | License along with this library; if not, write to the Free Software
|
---|
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
---|
18 |
|
---|
19 | Modified 23 November 2006 by David A. Mellis
|
---|
20 | */
|
---|
21 |
|
---|
22 | #include <stdlib.h>
|
---|
23 | #include <stdio.h>
|
---|
24 | #include <string.h>
|
---|
25 | #include <math.h>
|
---|
26 | #include "Arduino.h"
|
---|
27 | #include "Print.h"
|
---|
28 |
|
---|
29 | // Public Methods //////////////////////////////////////////////////////////////
|
---|
30 |
|
---|
31 | /* default implementation: may be overridden */
|
---|
32 | size_t Print::write(const uint8_t *buffer, size_t size)
|
---|
33 | {
|
---|
34 | size_t n = 0;
|
---|
35 | while (size--) {
|
---|
36 | n += write(*buffer++);
|
---|
37 | }
|
---|
38 | return n;
|
---|
39 | }
|
---|
40 |
|
---|
41 | size_t Print::print(const __FlashStringHelper *ifsh)
|
---|
42 | {
|
---|
43 | return print(reinterpret_cast<const char *>(ifsh));
|
---|
44 | }
|
---|
45 |
|
---|
46 | size_t Print::print(const String &s)
|
---|
47 | {
|
---|
48 | return write(s.c_str(), s.length());
|
---|
49 | }
|
---|
50 |
|
---|
51 | size_t Print::print(const char str[])
|
---|
52 | {
|
---|
53 | return write(str);
|
---|
54 | }
|
---|
55 |
|
---|
56 | size_t Print::print(char c)
|
---|
57 | {
|
---|
58 | return write(c);
|
---|
59 | }
|
---|
60 |
|
---|
61 | size_t Print::print(unsigned char b, int base)
|
---|
62 | {
|
---|
63 | return print((unsigned long) b, base);
|
---|
64 | }
|
---|
65 |
|
---|
66 | size_t Print::print(int n, int base)
|
---|
67 | {
|
---|
68 | return print((long) n, base);
|
---|
69 | }
|
---|
70 |
|
---|
71 | size_t Print::print(unsigned int n, int base)
|
---|
72 | {
|
---|
73 | return print((unsigned long) n, base);
|
---|
74 | }
|
---|
75 |
|
---|
76 | size_t Print::print(long n, int base)
|
---|
77 | {
|
---|
78 | if (base == 0) {
|
---|
79 | return write(n);
|
---|
80 | } else if (base == 10) {
|
---|
81 | if (n < 0) {
|
---|
82 | int t = print('-');
|
---|
83 | n = -n;
|
---|
84 | return printNumber(n, 10) + t;
|
---|
85 | }
|
---|
86 | return printNumber(n, 10);
|
---|
87 | } else {
|
---|
88 | return printNumber(n, base);
|
---|
89 | }
|
---|
90 | }
|
---|
91 |
|
---|
92 | size_t Print::print(unsigned long n, int base)
|
---|
93 | {
|
---|
94 | if (base == 0) return write(n);
|
---|
95 | else return printNumber(n, base);
|
---|
96 | }
|
---|
97 |
|
---|
98 | size_t Print::print(double n, int digits)
|
---|
99 | {
|
---|
100 | return printFloat(n, digits);
|
---|
101 | }
|
---|
102 |
|
---|
103 | size_t Print::println(const __FlashStringHelper *ifsh)
|
---|
104 | {
|
---|
105 | size_t n = print(ifsh);
|
---|
106 | n += println();
|
---|
107 | return n;
|
---|
108 | }
|
---|
109 |
|
---|
110 | size_t Print::print(const Printable& x)
|
---|
111 | {
|
---|
112 | return x.printTo(*this);
|
---|
113 | }
|
---|
114 |
|
---|
115 | size_t Print::println(void)
|
---|
116 | {
|
---|
117 | size_t n = print('\r');
|
---|
118 | n += print('\n');
|
---|
119 | return n;
|
---|
120 | }
|
---|
121 |
|
---|
122 | size_t Print::println(const String &s)
|
---|
123 | {
|
---|
124 | size_t n = print(s);
|
---|
125 | n += println();
|
---|
126 | return n;
|
---|
127 | }
|
---|
128 |
|
---|
129 | size_t Print::println(const char c[])
|
---|
130 | {
|
---|
131 | size_t n = print(c);
|
---|
132 | n += println();
|
---|
133 | return n;
|
---|
134 | }
|
---|
135 |
|
---|
136 | size_t Print::println(char c)
|
---|
137 | {
|
---|
138 | size_t n = print(c);
|
---|
139 | n += println();
|
---|
140 | return n;
|
---|
141 | }
|
---|
142 |
|
---|
143 | size_t Print::println(unsigned char b, int base)
|
---|
144 | {
|
---|
145 | size_t n = print(b, base);
|
---|
146 | n += println();
|
---|
147 | return n;
|
---|
148 | }
|
---|
149 |
|
---|
150 | size_t Print::println(int num, int base)
|
---|
151 | {
|
---|
152 | size_t n = print(num, base);
|
---|
153 | n += println();
|
---|
154 | return n;
|
---|
155 | }
|
---|
156 |
|
---|
157 | size_t Print::println(unsigned int num, int base)
|
---|
158 | {
|
---|
159 | size_t n = print(num, base);
|
---|
160 | n += println();
|
---|
161 | return n;
|
---|
162 | }
|
---|
163 |
|
---|
164 | size_t Print::println(long num, int base)
|
---|
165 | {
|
---|
166 | size_t n = print(num, base);
|
---|
167 | n += println();
|
---|
168 | return n;
|
---|
169 | }
|
---|
170 |
|
---|
171 | size_t Print::println(unsigned long num, int base)
|
---|
172 | {
|
---|
173 | size_t n = print(num, base);
|
---|
174 | n += println();
|
---|
175 | return n;
|
---|
176 | }
|
---|
177 |
|
---|
178 | size_t Print::println(double num, int digits)
|
---|
179 | {
|
---|
180 | size_t n = print(num, digits);
|
---|
181 | n += println();
|
---|
182 | return n;
|
---|
183 | }
|
---|
184 |
|
---|
185 | size_t Print::println(const Printable& x)
|
---|
186 | {
|
---|
187 | size_t n = print(x);
|
---|
188 | n += println();
|
---|
189 | return n;
|
---|
190 | }
|
---|
191 |
|
---|
192 | // Private Methods /////////////////////////////////////////////////////////////
|
---|
193 |
|
---|
194 | size_t Print::printNumber(unsigned long n, uint8_t base) {
|
---|
195 | char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
|
---|
196 | char *str = &buf[sizeof(buf) - 1];
|
---|
197 |
|
---|
198 | *str = '\0';
|
---|
199 |
|
---|
200 | // prevent crash if called with base == 1
|
---|
201 | if (base < 2) base = 10;
|
---|
202 |
|
---|
203 | do {
|
---|
204 | unsigned long m = n;
|
---|
205 | n /= base;
|
---|
206 | char c = m - base * n;
|
---|
207 | *--str = c < 10 ? c + '0' : c + 'A' - 10;
|
---|
208 | } while(n);
|
---|
209 |
|
---|
210 | return write(str);
|
---|
211 | }
|
---|
212 |
|
---|
213 | size_t Print::printFloat(double number, uint8_t digits)
|
---|
214 | {
|
---|
215 | size_t n = 0;
|
---|
216 |
|
---|
217 | if (isnan(number)) return print("nan");
|
---|
218 | if (isinf(number)) return print("inf");
|
---|
219 | if (number > 4294967040.0) return print ("ovf"); // constant determined empirically
|
---|
220 | if (number <-4294967040.0) return print ("ovf"); // constant determined empirically
|
---|
221 |
|
---|
222 | // Handle negative numbers
|
---|
223 | if (number < 0.0)
|
---|
224 | {
|
---|
225 | n += print('-');
|
---|
226 | number = -number;
|
---|
227 | }
|
---|
228 |
|
---|
229 | // Round correctly so that print(1.999, 2) prints as "2.00"
|
---|
230 | double rounding = 0.5;
|
---|
231 | for (uint8_t i=0; i<digits; ++i)
|
---|
232 | rounding /= 10.0;
|
---|
233 |
|
---|
234 | number += rounding;
|
---|
235 |
|
---|
236 | // Extract the integer part of the number and print it
|
---|
237 | unsigned long int_part = (unsigned long)number;
|
---|
238 | double remainder = number - (double)int_part;
|
---|
239 | n += print(int_part);
|
---|
240 |
|
---|
241 | // Print the decimal point, but only if there are digits beyond
|
---|
242 | if (digits > 0) {
|
---|
243 | n += print(".");
|
---|
244 | }
|
---|
245 |
|
---|
246 | // Extract digits from the remainder one at a time
|
---|
247 | while (digits-- > 0)
|
---|
248 | {
|
---|
249 | remainder *= 10.0;
|
---|
250 | int toPrint = int(remainder);
|
---|
251 | n += print(toPrint);
|
---|
252 | remainder -= toPrint;
|
---|
253 | }
|
---|
254 |
|
---|
255 | return n;
|
---|
256 | }
|
---|