Skip to content

Commit 8059abe

Browse files
damellisdamellis
committed
write(), print(), and println() now return number of bytes written.
The type is long, and negative values indicate errors. Needs more testing. http://code.google.com/p/arduino/issues/detail?id=551
1 parent b788ad5 commit 8059abe

File tree

24 files changed

+290
-174
lines changed

24 files changed

+290
-174
lines changed

‎hardware/arduino/cores/arduino/HardwareSerial.cpp

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -352,19 +352,22 @@ void HardwareSerial::flush()
352352
;
353353
}
354354

355-
void HardwareSerial::write(uint8_t c)
355+
long HardwareSerial::write(uint8_t c)
356356
{
357357
int i = (_tx_buffer->head + 1) % SERIAL_BUFFER_SIZE;
358358

359359
// If the output buffer is full, there's nothing for it other than to
360360
// wait for the interrupt handler to empty it a bit
361+
// ???: return 0 here instead?
361362
while (i == _tx_buffer->tail)
362363
;
363364

364365
_tx_buffer->buffer[_tx_buffer->head] = c;
365366
_tx_buffer->head = i;
366367

367368
sbi(*_ucsrb, _udrie);
369+
370+
return 1;
368371
}
369372

370373
// Preinstantiate Objects //////////////////////////////////////////////////////

‎hardware/arduino/cores/arduino/HardwareSerial.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -55,7 +55,7 @@ class HardwareSerial : public Stream
5555
virtual int peek(void);
5656
virtual int read(void);
5757
virtual void flush(void);
58-
virtual void write(uint8_t);
58+
virtual long write(uint8_t);
5959
using Print::write; // pull in write(str) and write(buf, size) from Print
6060
};
6161

‎hardware/arduino/cores/arduino/Print.cpp

Lines changed: 117 additions & 77 deletions
Original file line numberDiff line numberDiff line change
@@ -30,167 +30,196 @@
3030
// Public Methods //////////////////////////////////////////////////////////////
3131

3232
/* default implementation: may be overridden */
33-
void Print::write(const char *str)
33+
long Print::write(const char *str)
3434
{
35-
while (*str)
36-
write(*str++);
35+
long n = 0;
36+
while (*str) {
37+
if (write(*str++) <= 0) break;
38+
n++;
39+
}
40+
return n;
3741
}
3842

3943
/* default implementation: may be overridden */
40-
void Print::write(const uint8_t *buffer, size_t size)
44+
long Print::write(const uint8_t *buffer, size_t size)
4145
{
42-
while (size--)
43-
write(*buffer++);
46+
long n = 0;
47+
while (size--) {
48+
if (write(*buffer++) <= 0) break;
49+
n++;
50+
}
51+
return n;
4452
}
4553

46-
void Print::print(const __FlashStringHelper *ifsh)
54+
long Print::print(const __FlashStringHelper *ifsh)
4755
{
4856
const prog_char *p = (const prog_char *)ifsh;
57+
long n = 0;
4958
while (1) {
5059
unsigned char c = pgm_read_byte(p++);
51-
if (c == 0) return;
52-
write(c);
60+
if (c == 0) break;
61+
if (write(c) <= 0) break;
62+
n++;
5363
}
64+
return n;
5465
}
5566

56-
void Print::print(const String &s)
67+
long Print::print(const String &s)
5768
{
69+
long n = 0;
5870
for (int i = 0; i < s.length(); i++) {
59-
write(s[i]);
71+
if (write(s[i]) < 0) break;
72+
n++;
6073
}
74+
return n;
6175
}
6276

63-
void Print::print(const char str[])
77+
long Print::print(const char str[])
6478
{
65-
write(str);
79+
return write(str);
6680
}
6781

68-
void Print::print(char c)
82+
long Print::print(char c)
6983
{
70-
write(c);
84+
return write(c);
7185
}
7286

73-
void Print::print(unsigned char b, int base)
87+
long Print::print(unsigned char b, int base)
7488
{
75-
print((unsigned long) b, base);
89+
return print((unsigned long) b, base);
7690
}
7791

78-
void Print::print(int n, int base)
92+
long Print::print(int n, int base)
7993
{
80-
print((long) n, base);
94+
return print((long) n, base);
8195
}
8296

83-
void Print::print(unsigned int n, int base)
97+
long Print::print(unsigned int n, int base)
8498
{
85-
print((unsigned long) n, base);
99+
return print((unsigned long) n, base);
86100
}
87101

88-
void Print::print(long n, int base)
102+
long Print::print(long n, int base)
89103
{
90104
if (base == 0) {
91-
write(n);
105+
return write(n);
92106
} else if (base == 10) {
93107
if (n < 0) {
94-
print('-');
108+
long t = print('-');
109+
if (t <= 0) return t;
95110
n = -n;
111+
return printNumber(n, 10) + 1;
96112
}
97-
printNumber(n, 10);
113+
return printNumber(n, 10);
98114
} else {
99-
printNumber(n, base);
115+
return printNumber(n, base);
100116
}
101117
}
102118

103-
void Print::print(unsigned long n, int base)
119+
long Print::print(unsigned long n, int base)
104120
{
105-
if (base == 0) write(n);
106-
else printNumber(n, base);
121+
if (base == 0) return write(n);
122+
else return printNumber(n, base);
107123
}
108124

109-
void Print::print(double n, int digits)
125+
long Print::print(double n, int digits)
110126
{
111-
printFloat(n, digits);
127+
return printFloat(n, digits);
112128
}
113129

114-
void Print::println(const __FlashStringHelper *ifsh)
130+
long Print::println(const __FlashStringHelper *ifsh)
115131
{
116-
print(ifsh);
117-
println();
132+
long n = print(ifsh);
133+
if (n >= 0) n += println();
134+
return n;
118135
}
119136

120-
void Print::print(const Printable& x)
137+
long Print::print(const Printable& x)
121138
{
122-
x.printTo(*this);
139+
return x.printTo(*this);
123140
}
124141

125-
void Print::println(void)
142+
long Print::println(void)
126143
{
127-
print('\r');
128-
print('\n');
144+
long t = print('\r');
145+
if (t <= 0) return t;
146+
if (print('\n') <= 0) return 1;
147+
return 2;
129148
}
130149

131-
void Print::println(const String &s)
150+
long Print::println(const String &s)
132151
{
133-
print(s);
134-
println();
152+
long n = print(s);
153+
if (n >= 0) n += println();
154+
return n;
135155
}
136156

137-
void Print::println(const char c[])
157+
long Print::println(const char c[])
138158
{
139-
print(c);
140-
println();
159+
long n = print(c);
160+
if (n >= 0) n += println();
161+
return n;
141162
}
142163

143-
void Print::println(char c)
164+
long Print::println(char c)
144165
{
145-
print(c);
146-
println();
166+
long n = print(c);
167+
if (n > 0) n += println();
168+
return n;
147169
}
148170

149-
void Print::println(unsigned char b, int base)
171+
long Print::println(unsigned char b, int base)
150172
{
151-
print(b, base);
152-
println();
173+
long n = print(b, base);
174+
if (n >= 0) n += println();
175+
return n;
153176
}
154177

155-
void Print::println(int n, int base)
178+
long Print::println(int num, int base)
156179
{
157-
print(n, base);
158-
println();
180+
long n = print(num, base);
181+
if (n >= 0) n += println();
182+
return n;
159183
}
160184

161-
void Print::println(unsigned int n, int base)
185+
long Print::println(unsigned int num, int base)
162186
{
163-
print(n, base);
164-
println();
187+
long n = print(num, base);
188+
if (n >= 0) n += println();
189+
return n;
165190
}
166191

167-
void Print::println(long n, int base)
192+
long Print::println(long num, int base)
168193
{
169-
print(n, base);
170-
println();
194+
long n = print(num, base);
195+
if (n >= 0) n += println();
196+
return n;
171197
}
172198

173-
void Print::println(unsigned long n, int base)
199+
long Print::println(unsigned long num, int base)
174200
{
175-
print(n, base);
176-
println();
201+
long n = print(num, base);
202+
if (n >= 0) n += println();
203+
return n;
177204
}
178205

179-
void Print::println(double n, int digits)
206+
long Print::println(double num, int digits)
180207
{
181-
print(n, digits);
182-
println();
208+
long n = print(num, digits);
209+
if (n >= 0) n += println();
210+
return n;
183211
}
184212

185-
void Print::println(const Printable& x)
213+
long Print::println(const Printable& x)
186214
{
187-
print(x);
188-
println();
215+
long n = print(x);
216+
if (n >= 0) n += println();
217+
return n;
189218
}
190219

191220
// Private Methods /////////////////////////////////////////////////////////////
192221

193-
void Print::printNumber(unsigned long n, uint8_t base) {
222+
long Print::printNumber(unsigned long n, uint8_t base) {
194223
char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
195224
char *str = &buf[sizeof(buf) - 1];
196225

@@ -206,15 +235,17 @@ void Print::printNumber(unsigned long n, uint8_t base) {
206235
*--str = c < 10 ? c + '0' : c + 'A' - 10;
207236
} while(n);
208237

209-
write(str);
238+
return write(str);
210239
}
211240

212-
void Print::printFloat(double number, uint8_t digits)
241+
long Print::printFloat(double number, uint8_t digits)
213242
{
243+
long n = 0, t;
244+
214245
// Handle negative numbers
215246
if (number < 0.0)
216247
{
217-
print('-');
248+
if ((n = print('-')) <= 0) return n;
218249
number = -number;
219250
}
220251

@@ -228,18 +259,27 @@ void Print::printFloat(double number, uint8_t digits)
228259
// Extract the integer part of the number and print it
229260
unsigned long int_part = (unsigned long)number;
230261
double remainder = number - (double)int_part;
231-
print(int_part);
262+
if ((t = print(int_part)) < 0) return n;
263+
264+
n += t;
232265

233266
// Print the decimal point, but only if there are digits beyond
234-
if (digits > 0)
235-
print(".");
267+
if (digits > 0) {
268+
t = print(".");
269+
if (t <= 0) return n;
270+
n += t;
271+
}
236272

237273
// Extract digits from the remainder one at a time
238274
while (digits-- > 0)
239275
{
240276
remainder *= 10.0;
241277
int toPrint = int(remainder);
242-
print(toPrint);
278+
t = print(toPrint);
279+
if (t <= 0) return n;
280+
n += t;
243281
remainder -= toPrint;
244282
}
283+
284+
return n;
245285
}

0 commit comments

Comments
 (0)