root / arduino1.0 / hardware / arduino / cores / arduino / Print.cpp @ 58d82c77
History  View  Annotate  Download (5.09 KB)
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 021101301 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  
28 
#include "Print.h" 
29  
30 
// Public Methods //////////////////////////////////////////////////////////////

31  
32 
/* default implementation: may be overridden */

33 
size_t Print::write(const uint8_t *buffer, size_t size)

34 
{ 
35 
size_t n = 0;

36 
while (size) {

37 
n += write(*buffer++); 
38 
} 
39 
return n;

40 
} 
41  
42 
size_t Print::print(const __FlashStringHelper *ifsh)

43 
{ 
44 
const prog_char *p = (const prog_char *)ifsh; 
45 
size_t n = 0;

46 
while (1) { 
47 
unsigned char c = pgm_read_byte(p++); 
48 
if (c == 0) break; 
49 
n += write(c); 
50 
} 
51 
return n;

52 
} 
53  
54 
size_t Print::print(const String &s)

55 
{ 
56 
size_t n = 0;

57 
for (uint16_t i = 0; i < s.length(); i++) { 
58 
n += write(s[i]); 
59 
} 
60 
return n;

61 
} 
62  
63 
size_t Print::print(const char str[]) 
64 
{ 
65 
return write(str);

66 
} 
67  
68 
size_t Print::print(char c)

69 
{ 
70 
return write(c);

71 
} 
72  
73 
size_t Print::print(unsigned char b, int base) 
74 
{ 
75 
return print((unsigned long) b, base); 
76 
} 
77  
78 
size_t Print::print(int n, int base) 
79 
{ 
80 
return print((long) n, base); 
81 
} 
82  
83 
size_t Print::print(unsigned int n, int base) 
84 
{ 
85 
return print((unsigned long) n, base); 
86 
} 
87  
88 
size_t Print::print(long n, int base) 
89 
{ 
90 
if (base == 0) { 
91 
return write(n);

92 
} else if (base == 10) { 
93 
if (n < 0) { 
94 
int t = print(''); 
95 
n = n; 
96 
return printNumber(n, 10) + t; 
97 
} 
98 
return printNumber(n, 10); 
99 
} else {

100 
return printNumber(n, base);

101 
} 
102 
} 
103  
104 
size_t Print::print(unsigned long n, int base) 
105 
{ 
106 
if (base == 0) return write(n); 
107 
else return printNumber(n, base); 
108 
} 
109  
110 
size_t Print::print(double n, int digits) 
111 
{ 
112 
return printFloat(n, digits);

113 
} 
114  
115 
size_t Print::println(const __FlashStringHelper *ifsh)

116 
{ 
117 
size_t n = print(ifsh); 
118 
n += println(); 
119 
return n;

120 
} 
121  
122 
size_t Print::print(const Printable& x)

123 
{ 
124 
return x.printTo(*this); 
125 
} 
126  
127 
size_t Print::println(void)

128 
{ 
129 
size_t n = print('\r');

130 
n += print('\n');

131 
return n;

132 
} 
133  
134 
size_t Print::println(const String &s)

135 
{ 
136 
size_t n = print(s); 
137 
n += println(); 
138 
return n;

139 
} 
140  
141 
size_t Print::println(const char c[]) 
142 
{ 
143 
size_t n = print(c); 
144 
n += println(); 
145 
return n;

146 
} 
147  
148 
size_t Print::println(char c)

149 
{ 
150 
size_t n = print(c); 
151 
n += println(); 
152 
return n;

153 
} 
154  
155 
size_t Print::println(unsigned char b, int base) 
156 
{ 
157 
size_t n = print(b, base); 
158 
n += println(); 
159 
return n;

160 
} 
161  
162 
size_t Print::println(int num, int base) 
163 
{ 
164 
size_t n = print(num, base); 
165 
n += println(); 
166 
return n;

167 
} 
168  
169 
size_t Print::println(unsigned int num, int base) 
170 
{ 
171 
size_t n = print(num, base); 
172 
n += println(); 
173 
return n;

174 
} 
175  
176 
size_t Print::println(long num, int base) 
177 
{ 
178 
size_t n = print(num, base); 
179 
n += println(); 
180 
return n;

181 
} 
182  
183 
size_t Print::println(unsigned long num, int base) 
184 
{ 
185 
size_t n = print(num, base); 
186 
n += println(); 
187 
return n;

188 
} 
189  
190 
size_t Print::println(double num, int digits) 
191 
{ 
192 
size_t n = print(num, digits); 
193 
n += println(); 
194 
return n;

195 
} 
196  
197 
size_t Print::println(const Printable& x)

198 
{ 
199 
size_t n = print(x); 
200 
n += println(); 
201 
return n;

202 
} 
203  
204 
// Private Methods /////////////////////////////////////////////////////////////

205  
206 
size_t Print::printNumber(unsigned long n, uint8_t base) { 
207 
char buf[8 * sizeof(long) + 1]; // Assumes 8bit chars plus zero byte. 
208 
char *str = &buf[sizeof(buf)  1]; 
209  
210 
*str = '\0';

211  
212 
// prevent crash if called with base == 1

213 
if (base < 2) base = 10; 
214  
215 
do {

216 
unsigned long m = n; 
217 
n /= base; 
218 
char c = m  base * n;

219 
*str = c < 10 ? c + '0' : c + 'A'  10; 
220 
} while(n);

221  
222 
return write(str);

223 
} 
224  
225 
size_t Print::printFloat(double number, uint8_t digits)

226 
{ 
227 
size_t n = 0;

228 

229 
// Handle negative numbers

230 
if (number < 0.0) 
231 
{ 
232 
n += print('');

233 
number = number; 
234 
} 
235  
236 
// Round correctly so that print(1.999, 2) prints as "2.00"

237 
double rounding = 0.5; 
238 
for (uint8_t i=0; i<digits; ++i) 
239 
rounding /= 10.0; 
240 

241 
number += rounding; 
242  
243 
// Extract the integer part of the number and print it

244 
unsigned long int_part = (unsigned long)number; 
245 
double remainder = number  (double)int_part; 
246 
n += print(int_part); 
247  
248 
// Print the decimal point, but only if there are digits beyond

249 
if (digits > 0) { 
250 
n += print(".");

251 
} 
252  
253 
// Extract digits from the remainder one at a time

254 
while (digits > 0) 
255 
{ 
256 
remainder *= 10.0; 
257 
int toPrint = int(remainder); 
258 
n += print(toPrint); 
259 
remainder = toPrint; 
260 
} 
261 

262 
return n;

263 
} 