sanguino/cores/arduino/HardwareSerial.cpp

changeset 2
b373b0288715
equal deleted inserted replaced
1:b584642d4f58 2:b373b0288715
1 /*
2 HardwareSerial.cpp - Hardware serial library for Wiring
3 Copyright (c) 2006 Nicholas Zambetti. 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 Modified 28 September 2010 by Mark Sproul
21 */
22
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <string.h>
26 #include <inttypes.h>
27 #include "Arduino.h"
28 #include "wiring_private.h"
29
30 // this next line disables the entire HardwareSerial.cpp,
31 // this is so I can support Attiny series and any other chip without a uart
32 #if defined(UBRRH) || defined(UBRR0H) || defined(UBRR1H) || defined(UBRR2H) || defined(UBRR3H)
33
34 #include "HardwareSerial.h"
35
36 // Define constants and variables for buffering incoming serial data. We're
37 // using a ring buffer (I think), in which head is the index of the location
38 // to which to write the next incoming character and tail is the index of the
39 // location from which to read.
40 #if (RAMEND < 1000)
41 #define SERIAL_BUFFER_SIZE 16
42 #else
43 #define SERIAL_BUFFER_SIZE 64
44 #endif
45
46 struct ring_buffer
47 {
48 unsigned char buffer[SERIAL_BUFFER_SIZE];
49 volatile unsigned int head;
50 volatile unsigned int tail;
51 };
52
53 #if defined(USBCON)
54 ring_buffer rx_buffer = { { 0 }, 0, 0};
55 ring_buffer tx_buffer = { { 0 }, 0, 0};
56 #endif
57 #if defined(UBRRH) || defined(UBRR0H)
58 ring_buffer rx_buffer = { { 0 }, 0, 0 };
59 ring_buffer tx_buffer = { { 0 }, 0, 0 };
60 #endif
61 #if defined(UBRR1H)
62 ring_buffer rx_buffer1 = { { 0 }, 0, 0 };
63 ring_buffer tx_buffer1 = { { 0 }, 0, 0 };
64 #endif
65 #if defined(UBRR2H)
66 ring_buffer rx_buffer2 = { { 0 }, 0, 0 };
67 ring_buffer tx_buffer2 = { { 0 }, 0, 0 };
68 #endif
69 #if defined(UBRR3H)
70 ring_buffer rx_buffer3 = { { 0 }, 0, 0 };
71 ring_buffer tx_buffer3 = { { 0 }, 0, 0 };
72 #endif
73
74 inline void store_char(unsigned char c, ring_buffer *buffer)
75 {
76 int i = (unsigned int)(buffer->head + 1) % SERIAL_BUFFER_SIZE;
77
78 // if we should be storing the received character into the location
79 // just before the tail (meaning that the head would advance to the
80 // current location of the tail), we're about to overflow the buffer
81 // and so we don't write the character or advance the head.
82 if (i != buffer->tail) {
83 buffer->buffer[buffer->head] = c;
84 buffer->head = i;
85 }
86 }
87
88 #if !defined(USART0_RX_vect) && defined(USART1_RX_vect)
89 // do nothing - on the 32u4 the first USART is USART1
90 #else
91 #if !defined(USART_RX_vect) && !defined(SIG_USART0_RECV) && \
92 !defined(SIG_UART0_RECV) && !defined(USART0_RX_vect) && \
93 !defined(SIG_UART_RECV)
94 #error "Don't know what the Data Received vector is called for the first UART"
95 #else
96 void serialEvent() __attribute__((weak));
97 void serialEvent() {}
98 #define serialEvent_implemented
99 #if defined(USART_RX_vect)
100 SIGNAL(USART_RX_vect)
101 #elif defined(SIG_USART0_RECV)
102 SIGNAL(SIG_USART0_RECV)
103 #elif defined(SIG_UART0_RECV)
104 SIGNAL(SIG_UART0_RECV)
105 #elif defined(USART0_RX_vect)
106 SIGNAL(USART0_RX_vect)
107 #elif defined(SIG_UART_RECV)
108 SIGNAL(SIG_UART_RECV)
109 #endif
110 {
111 #if defined(UDR0)
112 unsigned char c = UDR0;
113 #elif defined(UDR)
114 unsigned char c = UDR;
115 #else
116 #error UDR not defined
117 #endif
118 store_char(c, &rx_buffer);
119 }
120 #endif
121 #endif
122
123 #if defined(USART1_RX_vect)
124 void serialEvent1() __attribute__((weak));
125 void serialEvent1() {}
126 #define serialEvent1_implemented
127 SIGNAL(USART1_RX_vect)
128 {
129 unsigned char c = UDR1;
130 store_char(c, &rx_buffer1);
131 }
132 #elif defined(SIG_USART1_RECV)
133 #error SIG_USART1_RECV
134 #endif
135
136 #if defined(USART2_RX_vect) && defined(UDR2)
137 void serialEvent2() __attribute__((weak));
138 void serialEvent2() {}
139 #define serialEvent2_implemented
140 SIGNAL(USART2_RX_vect)
141 {
142 unsigned char c = UDR2;
143 store_char(c, &rx_buffer2);
144 }
145 #elif defined(SIG_USART2_RECV)
146 #error SIG_USART2_RECV
147 #endif
148
149 #if defined(USART3_RX_vect) && defined(UDR3)
150 void serialEvent3() __attribute__((weak));
151 void serialEvent3() {}
152 #define serialEvent3_implemented
153 SIGNAL(USART3_RX_vect)
154 {
155 unsigned char c = UDR3;
156 store_char(c, &rx_buffer3);
157 }
158 #elif defined(SIG_USART3_RECV)
159 #error SIG_USART3_RECV
160 #endif
161
162 void serialEventRun(void)
163 {
164 #ifdef serialEvent_implemented
165 if (Serial.available()) serialEvent();
166 #endif
167 #ifdef serialEvent1_implemented
168 if (Serial1.available()) serialEvent1();
169 #endif
170 #ifdef serialEvent2_implemented
171 if (Serial2.available()) serialEvent2();
172 #endif
173 #ifdef serialEvent3_implemented
174 if (Serial3.available()) serialEvent3();
175 #endif
176 }
177
178
179 #if !defined(USART0_UDRE_vect) && defined(USART1_UDRE_vect)
180 // do nothing - on the 32u4 the first USART is USART1
181 #else
182 #if !defined(UART0_UDRE_vect) && !defined(UART_UDRE_vect) && !defined(USART0_UDRE_vect) && !defined(USART_UDRE_vect)
183 #error "Don't know what the Data Register Empty vector is called for the first UART"
184 #else
185 #if defined(UART0_UDRE_vect)
186 ISR(UART0_UDRE_vect)
187 #elif defined(UART_UDRE_vect)
188 ISR(UART_UDRE_vect)
189 #elif defined(USART0_UDRE_vect)
190 ISR(USART0_UDRE_vect)
191 #elif defined(USART_UDRE_vect)
192 ISR(USART_UDRE_vect)
193 #endif
194 {
195 if (tx_buffer.head == tx_buffer.tail) {
196 // Buffer empty, so disable interrupts
197 #if defined(UCSR0B)
198 cbi(UCSR0B, UDRIE0);
199 #else
200 cbi(UCSRB, UDRIE);
201 #endif
202 }
203 else {
204 // There is more data in the output buffer. Send the next byte
205 unsigned char c = tx_buffer.buffer[tx_buffer.tail];
206 tx_buffer.tail = (tx_buffer.tail + 1) % SERIAL_BUFFER_SIZE;
207
208 #if defined(UDR0)
209 UDR0 = c;
210 #elif defined(UDR)
211 UDR = c;
212 #else
213 #error UDR not defined
214 #endif
215 }
216 }
217 #endif
218 #endif
219
220 #ifdef USART1_UDRE_vect
221 ISR(USART1_UDRE_vect)
222 {
223 if (tx_buffer1.head == tx_buffer1.tail) {
224 // Buffer empty, so disable interrupts
225 cbi(UCSR1B, UDRIE1);
226 }
227 else {
228 // There is more data in the output buffer. Send the next byte
229 unsigned char c = tx_buffer1.buffer[tx_buffer1.tail];
230 tx_buffer1.tail = (tx_buffer1.tail + 1) % SERIAL_BUFFER_SIZE;
231
232 UDR1 = c;
233 }
234 }
235 #endif
236
237 #ifdef USART2_UDRE_vect
238 ISR(USART2_UDRE_vect)
239 {
240 if (tx_buffer2.head == tx_buffer2.tail) {
241 // Buffer empty, so disable interrupts
242 cbi(UCSR2B, UDRIE2);
243 }
244 else {
245 // There is more data in the output buffer. Send the next byte
246 unsigned char c = tx_buffer2.buffer[tx_buffer2.tail];
247 tx_buffer2.tail = (tx_buffer2.tail + 1) % SERIAL_BUFFER_SIZE;
248
249 UDR2 = c;
250 }
251 }
252 #endif
253
254 #ifdef USART3_UDRE_vect
255 ISR(USART3_UDRE_vect)
256 {
257 if (tx_buffer3.head == tx_buffer3.tail) {
258 // Buffer empty, so disable interrupts
259 cbi(UCSR3B, UDRIE3);
260 }
261 else {
262 // There is more data in the output buffer. Send the next byte
263 unsigned char c = tx_buffer3.buffer[tx_buffer3.tail];
264 tx_buffer3.tail = (tx_buffer3.tail + 1) % SERIAL_BUFFER_SIZE;
265
266 UDR3 = c;
267 }
268 }
269 #endif
270
271
272 // Constructors ////////////////////////////////////////////////////////////////
273
274 HardwareSerial::HardwareSerial(ring_buffer *rx_buffer, ring_buffer *tx_buffer,
275 volatile uint8_t *ubrrh, volatile uint8_t *ubrrl,
276 volatile uint8_t *ucsra, volatile uint8_t *ucsrb,
277 volatile uint8_t *udr,
278 uint8_t rxen, uint8_t txen, uint8_t rxcie, uint8_t udrie, uint8_t u2x)
279 {
280 _rx_buffer = rx_buffer;
281 _tx_buffer = tx_buffer;
282 _ubrrh = ubrrh;
283 _ubrrl = ubrrl;
284 _ucsra = ucsra;
285 _ucsrb = ucsrb;
286 _udr = udr;
287 _rxen = rxen;
288 _txen = txen;
289 _rxcie = rxcie;
290 _udrie = udrie;
291 _u2x = u2x;
292 }
293
294 // Public Methods //////////////////////////////////////////////////////////////
295
296 void HardwareSerial::begin(unsigned long baud)
297 {
298 uint16_t baud_setting;
299 bool use_u2x = true;
300
301 #if F_CPU == 16000000UL
302 // hardcoded exception for compatibility with the bootloader shipped
303 // with the Duemilanove and previous boards and the firmware on the 8U2
304 // on the Uno and Mega 2560.
305 if (baud == 57600) {
306 use_u2x = false;
307 }
308 #endif
309
310 try_again:
311
312 if (use_u2x) {
313 *_ucsra = 1 << _u2x;
314 baud_setting = (F_CPU / 4 / baud - 1) / 2;
315 } else {
316 *_ucsra = 0;
317 baud_setting = (F_CPU / 8 / baud - 1) / 2;
318 }
319
320 if ((baud_setting > 4095) && use_u2x)
321 {
322 use_u2x = false;
323 goto try_again;
324 }
325
326 // assign the baud_setting, a.k.a. ubbr (USART Baud Rate Register)
327 *_ubrrh = baud_setting >> 8;
328 *_ubrrl = baud_setting;
329
330 sbi(*_ucsrb, _rxen);
331 sbi(*_ucsrb, _txen);
332 sbi(*_ucsrb, _rxcie);
333 cbi(*_ucsrb, _udrie);
334 }
335
336 void HardwareSerial::end()
337 {
338 // wait for transmission of outgoing data
339 while (_tx_buffer->head != _tx_buffer->tail)
340 ;
341
342 cbi(*_ucsrb, _rxen);
343 cbi(*_ucsrb, _txen);
344 cbi(*_ucsrb, _rxcie);
345 cbi(*_ucsrb, _udrie);
346
347 // clear any received data
348 _rx_buffer->head = _rx_buffer->tail;
349 }
350
351 int HardwareSerial::available(void)
352 {
353 return (unsigned int)(SERIAL_BUFFER_SIZE + _rx_buffer->head - _rx_buffer->tail) % SERIAL_BUFFER_SIZE;
354 }
355
356 int HardwareSerial::peek(void)
357 {
358 if (_rx_buffer->head == _rx_buffer->tail) {
359 return -1;
360 } else {
361 return _rx_buffer->buffer[_rx_buffer->tail];
362 }
363 }
364
365 int HardwareSerial::read(void)
366 {
367 // if the head isn't ahead of the tail, we don't have any characters
368 if (_rx_buffer->head == _rx_buffer->tail) {
369 return -1;
370 } else {
371 unsigned char c = _rx_buffer->buffer[_rx_buffer->tail];
372 _rx_buffer->tail = (unsigned int)(_rx_buffer->tail + 1) % SERIAL_BUFFER_SIZE;
373 return c;
374 }
375 }
376
377 void HardwareSerial::flush()
378 {
379 while (_tx_buffer->head != _tx_buffer->tail)
380 ;
381 }
382
383 size_t HardwareSerial::write(uint8_t c)
384 {
385 int i = (_tx_buffer->head + 1) % SERIAL_BUFFER_SIZE;
386
387 // If the output buffer is full, there's nothing for it other than to
388 // wait for the interrupt handler to empty it a bit
389 // ???: return 0 here instead?
390 while (i == _tx_buffer->tail)
391 ;
392
393 _tx_buffer->buffer[_tx_buffer->head] = c;
394 _tx_buffer->head = i;
395
396 sbi(*_ucsrb, _udrie);
397
398 return 1;
399 }
400
401 HardwareSerial::operator bool() {
402 return true;
403 }
404
405 // Preinstantiate Objects //////////////////////////////////////////////////////
406
407 #if defined(UBRRH) && defined(UBRRL)
408 HardwareSerial Serial(&rx_buffer, &tx_buffer, &UBRRH, &UBRRL, &UCSRA, &UCSRB, &UDR, RXEN, TXEN, RXCIE, UDRIE, U2X);
409 #elif defined(UBRR0H) && defined(UBRR0L)
410 HardwareSerial Serial(&rx_buffer, &tx_buffer, &UBRR0H, &UBRR0L, &UCSR0A, &UCSR0B, &UDR0, RXEN0, TXEN0, RXCIE0, UDRIE0, U2X0);
411 #elif defined(USBCON)
412 // do nothing - Serial object and buffers are initialized in CDC code
413 #else
414 #error no serial port defined (port 0)
415 #endif
416
417 #if defined(UBRR1H)
418 HardwareSerial Serial1(&rx_buffer1, &tx_buffer1, &UBRR1H, &UBRR1L, &UCSR1A, &UCSR1B, &UDR1, RXEN1, TXEN1, RXCIE1, UDRIE1, U2X1);
419 #endif
420 #if defined(UBRR2H)
421 HardwareSerial Serial2(&rx_buffer2, &tx_buffer2, &UBRR2H, &UBRR2L, &UCSR2A, &UCSR2B, &UDR2, RXEN2, TXEN2, RXCIE2, UDRIE2, U2X2);
422 #endif
423 #if defined(UBRR3H)
424 HardwareSerial Serial3(&rx_buffer3, &tx_buffer3, &UBRR3H, &UBRR3L, &UCSR3A, &UCSR3B, &UDR3, RXEN3, TXEN3, RXCIE3, UDRIE3, U2X3);
425 #endif
426
427 #endif // whole file
428

mercurial