2009-06-01 01:32:11 -07:00
|
|
|
/*
|
|
|
|
HardwareSerial.h - Hardware serial library for Wiring
|
|
|
|
Copyright (c) 2006 Nicholas Zambetti. All right reserved.
|
|
|
|
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
|
|
modify it under the terms of the GNU Lesser General Public
|
|
|
|
License as published by the Free Software Foundation; either
|
|
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
Lesser General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
|
|
License along with this library; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
2010-10-17 10:36:02 -07:00
|
|
|
|
|
|
|
Modified 28 September 2010 by Mark Sproul
|
2012-08-14 06:52:00 -07:00
|
|
|
Modified 14 August 2012 by Alarus
|
2014-02-07 07:52:10 -08:00
|
|
|
Modified 3 December 2013 by Matthijs Kooijman
|
2009-06-01 01:32:11 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef HardwareSerial_h
|
|
|
|
#define HardwareSerial_h
|
|
|
|
|
|
|
|
#include <inttypes.h>
|
|
|
|
|
2010-05-28 15:41:03 -07:00
|
|
|
#include "Stream.h"
|
2009-06-01 01:32:11 -07:00
|
|
|
|
2013-04-18 09:52:48 -07:00
|
|
|
// Define constants and variables for buffering incoming serial data. We're
|
|
|
|
// using a ring buffer (I think), in which head is the index of the location
|
|
|
|
// to which to write the next incoming character and tail is the index of the
|
|
|
|
// location from which to read.
|
2014-10-21 08:47:59 -07:00
|
|
|
// NOTE: a "power of 2" buffer size is reccomended to dramatically
|
|
|
|
// optimize all the modulo operations for ring buffers.
|
2015-06-18 07:34:53 -07:00
|
|
|
// WARNING: When buffer sizes are increased to > 256, the buffer index
|
|
|
|
// variables are automatically increased in size, but the extra
|
|
|
|
// atomicity guards needed for that are not implemented. This will
|
|
|
|
// often work, but occasionally a race condition can occur that makes
|
|
|
|
// Serial behave erratically. See https://github.com/arduino/Arduino/issues/2405
|
2015-02-02 11:27:17 -08:00
|
|
|
#if !defined(SERIAL_TX_BUFFER_SIZE)
|
2015-09-20 02:07:19 -07:00
|
|
|
#if ((RAMEND - RAMSTART) < 1023)
|
2014-03-23 15:12:00 -07:00
|
|
|
#define SERIAL_TX_BUFFER_SIZE 16
|
2013-04-18 09:52:48 -07:00
|
|
|
#else
|
2014-03-23 15:12:00 -07:00
|
|
|
#define SERIAL_TX_BUFFER_SIZE 64
|
2015-02-02 11:27:17 -08:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#if !defined(SERIAL_RX_BUFFER_SIZE)
|
2015-09-20 02:07:19 -07:00
|
|
|
#if ((RAMEND - RAMSTART) < 1023)
|
2015-02-02 11:27:17 -08:00
|
|
|
#define SERIAL_RX_BUFFER_SIZE 16
|
|
|
|
#else
|
2014-03-23 15:12:00 -07:00
|
|
|
#define SERIAL_RX_BUFFER_SIZE 64
|
|
|
|
#endif
|
|
|
|
#endif
|
2014-03-24 13:40:12 -07:00
|
|
|
#if (SERIAL_TX_BUFFER_SIZE>256)
|
|
|
|
typedef uint16_t tx_buffer_index_t;
|
2014-03-23 15:12:00 -07:00
|
|
|
#else
|
2014-03-24 13:40:12 -07:00
|
|
|
typedef uint8_t tx_buffer_index_t;
|
|
|
|
#endif
|
|
|
|
#if (SERIAL_RX_BUFFER_SIZE>256)
|
|
|
|
typedef uint16_t rx_buffer_index_t;
|
|
|
|
#else
|
|
|
|
typedef uint8_t rx_buffer_index_t;
|
2013-04-18 09:52:48 -07:00
|
|
|
#endif
|
2009-06-01 01:32:11 -07:00
|
|
|
|
2014-01-16 04:50:59 -08:00
|
|
|
// Define config for Serial.begin(baud, config);
|
|
|
|
#define SERIAL_5N1 0x00
|
|
|
|
#define SERIAL_6N1 0x02
|
|
|
|
#define SERIAL_7N1 0x04
|
|
|
|
#define SERIAL_8N1 0x06
|
|
|
|
#define SERIAL_5N2 0x08
|
|
|
|
#define SERIAL_6N2 0x0A
|
|
|
|
#define SERIAL_7N2 0x0C
|
|
|
|
#define SERIAL_8N2 0x0E
|
|
|
|
#define SERIAL_5E1 0x20
|
|
|
|
#define SERIAL_6E1 0x22
|
|
|
|
#define SERIAL_7E1 0x24
|
|
|
|
#define SERIAL_8E1 0x26
|
|
|
|
#define SERIAL_5E2 0x28
|
|
|
|
#define SERIAL_6E2 0x2A
|
|
|
|
#define SERIAL_7E2 0x2C
|
|
|
|
#define SERIAL_8E2 0x2E
|
|
|
|
#define SERIAL_5O1 0x30
|
|
|
|
#define SERIAL_6O1 0x32
|
|
|
|
#define SERIAL_7O1 0x34
|
|
|
|
#define SERIAL_8O1 0x36
|
|
|
|
#define SERIAL_5O2 0x38
|
|
|
|
#define SERIAL_6O2 0x3A
|
|
|
|
#define SERIAL_7O2 0x3C
|
|
|
|
#define SERIAL_8O2 0x3E
|
|
|
|
|
2010-05-28 15:41:03 -07:00
|
|
|
class HardwareSerial : public Stream
|
2009-06-01 01:32:11 -07:00
|
|
|
{
|
2013-04-18 09:46:14 -07:00
|
|
|
protected:
|
2014-01-22 01:12:56 -08:00
|
|
|
volatile uint8_t * const _ubrrh;
|
|
|
|
volatile uint8_t * const _ubrrl;
|
|
|
|
volatile uint8_t * const _ucsra;
|
|
|
|
volatile uint8_t * const _ucsrb;
|
|
|
|
volatile uint8_t * const _ucsrc;
|
|
|
|
volatile uint8_t * const _udr;
|
Improve HardwareSerial::flush()
The flush() method blocks until all characters in the serial buffer have
been written to the uart _and_ transmitted. This is checked by waiting
until the "TXC" (TX Complete) bit is set by the UART, signalling
completion. This bit is cleared by write() when adding a new byte to the
buffer and set by the hardware after tranmission ends, so it is always
guaranteed to be zero from the moment the first byte in a sequence is
queued until the moment the last byte is transmitted, and it is one from
the moment the last byte in the buffer is transmitted until the first
byte in the next sequence is queued.
However, the TXC bit is also zero from initialization to the moment the
first byte ever is queued (and then continues to be zero until the first
sequence of bytes completes transmission). Unfortunately we cannot
manually set the TXC bit during initialization, we can only clear it. To
make sure that flush() would not (indefinitely) block when it is called
_before_ anything was written to the serial device, the "transmitting"
variable was introduced.
This variable suggests that it is only true when something is
transmitting, which isn't currently the case (it remains true after
transmission is complete until flush() is called, for example).
Furthermore, there is no need to keep the status of transmission, the
only thing needed is to remember if anything has ever been written, so
the corner case described above can be detected.
This commit improves the code by:
- Renaming the "transmitting" variable to _written (making it more
clear and following the leading underscore naming convention).
- Not resetting the value of _written at the end of flush(), there is
no point to this.
- Only checking the "_written" value once in flush(), since it can
never be toggled off anyway.
- Initializing the value of _written in both versions of _begin (though
it probably gets initialized to 0 by default anyway, better to be
explicit).
2013-04-18 12:12:01 -07:00
|
|
|
// Has any byte been written to the UART since begin()
|
|
|
|
bool _written;
|
2013-04-18 09:52:48 -07:00
|
|
|
|
2014-03-24 13:40:12 -07:00
|
|
|
volatile rx_buffer_index_t _rx_buffer_head;
|
|
|
|
volatile rx_buffer_index_t _rx_buffer_tail;
|
|
|
|
volatile tx_buffer_index_t _tx_buffer_head;
|
|
|
|
volatile tx_buffer_index_t _tx_buffer_tail;
|
2013-04-18 09:52:48 -07:00
|
|
|
|
|
|
|
// Don't put any members after these buffers, since only the first
|
|
|
|
// 32 bytes of this struct can be accessed quickly using the ldd
|
|
|
|
// instruction.
|
2014-03-23 15:12:00 -07:00
|
|
|
unsigned char _rx_buffer[SERIAL_RX_BUFFER_SIZE];
|
|
|
|
unsigned char _tx_buffer[SERIAL_TX_BUFFER_SIZE];
|
2013-04-18 09:52:48 -07:00
|
|
|
|
2013-04-18 02:38:13 -07:00
|
|
|
public:
|
2014-01-22 01:12:56 -08:00
|
|
|
inline HardwareSerial(
|
2009-06-01 01:32:11 -07:00
|
|
|
volatile uint8_t *ubrrh, volatile uint8_t *ubrrl,
|
|
|
|
volatile uint8_t *ucsra, volatile uint8_t *ucsrb,
|
Use constants for register bit positions in HardwareSerial
Previously, the constants to use for the bit positions of the various
UARTs were passed to the HardwareSerial constructor. However, this
meant that whenever these values were used, the had to be indirectly
loaded, resulting in extra code overhead. Additionally, since there is
no instruction to shift a value by a variable amount, the 1 << x
expressions (inside _BV and sbi() / cbi()) would be compiled as a loop
instead of being evaluated at compiletime.
Now, the HardwareSerial class always uses the constants for the bit
positions of UART 0 (and some code is present to make sure these
constants exist, even for targets that only have a single unnumbered
UART or start at UART1).
This was already done for the TXC0 constant, for some reason. For the
actual register addresses, this approach does not work, since these are
of course different between the different UARTs on a single chip.
Of course, always using the UART 0 constants is only correct when the
constants are actually identical for the different UARTs. It has been
verified that this is currently the case for all targets supported by
avr-gcc 4.7.2, and the code contains compile-time checks to verify this
for the current target, in case a new target is added for which this
does not hold. This verification was done using:
for i in TXC RXEN TXEN RXCIE UDRIE U2X UPE; do echo $i; grep --no-filename -r "#define $i[0-9]\? " /usr/lib/avr/include/avr/io* | sed "s/#define $i[0-9]\?\s*\(\S\)\+\s*\(\/\*.*\*\/\)\?$/\1/" | sort | uniq ; done
This command shows that the above constants are identical for all uarts
on all platforms, except for TXC, which is sometimes 6 and sometimes 0.
Further investigation shows that it is always 6, except in io90scr100.h,
but that file defines TXC0 with value 6 for the UART and uses TXC with
value 0 for some USB-related register.
This commit reduces program size on the uno by around 120 bytes.
2013-04-18 05:17:47 -07:00
|
|
|
volatile uint8_t *ucsrc, volatile uint8_t *udr);
|
2014-01-16 04:50:59 -08:00
|
|
|
void begin(unsigned long baud) { begin(baud, SERIAL_8N1); }
|
2012-11-02 06:24:51 -07:00
|
|
|
void begin(unsigned long, uint8_t);
|
2009-12-22 16:00:17 -08:00
|
|
|
void end();
|
2010-08-02 15:23:48 -07:00
|
|
|
virtual int available(void);
|
2010-07-04 16:31:55 -07:00
|
|
|
virtual int peek(void);
|
2010-05-28 15:41:03 -07:00
|
|
|
virtual int read(void);
|
2014-07-18 07:01:26 -07:00
|
|
|
int availableForWrite(void);
|
2010-05-28 15:41:03 -07:00
|
|
|
virtual void flush(void);
|
2011-10-27 08:45:13 -07:00
|
|
|
virtual size_t write(uint8_t);
|
2012-08-29 13:32:05 -07:00
|
|
|
inline size_t write(unsigned long n) { return write((uint8_t)n); }
|
|
|
|
inline size_t write(long n) { return write((uint8_t)n); }
|
|
|
|
inline size_t write(unsigned int n) { return write((uint8_t)n); }
|
|
|
|
inline size_t write(int n) { return write((uint8_t)n); }
|
2009-06-01 01:32:11 -07:00
|
|
|
using Print::write; // pull in write(str) and write(buf, size) from Print
|
2014-01-16 04:50:59 -08:00
|
|
|
operator bool() { return true; }
|
2013-04-18 02:38:13 -07:00
|
|
|
|
|
|
|
// Interrupt handlers - Not intended to be called externally
|
2014-01-22 01:12:56 -08:00
|
|
|
inline void _rx_complete_irq(void);
|
2013-04-18 02:38:13 -07:00
|
|
|
void _tx_udr_empty_irq(void);
|
2009-06-01 01:32:11 -07:00
|
|
|
};
|
|
|
|
|
2010-10-17 10:36:02 -07:00
|
|
|
#if defined(UBRRH) || defined(UBRR0H)
|
|
|
|
extern HardwareSerial Serial;
|
2013-12-01 08:21:54 -08:00
|
|
|
#define HAVE_HWSERIAL0
|
2010-10-17 10:36:02 -07:00
|
|
|
#endif
|
|
|
|
#if defined(UBRR1H)
|
|
|
|
extern HardwareSerial Serial1;
|
2013-12-01 08:21:54 -08:00
|
|
|
#define HAVE_HWSERIAL1
|
2010-10-17 10:36:02 -07:00
|
|
|
#endif
|
|
|
|
#if defined(UBRR2H)
|
|
|
|
extern HardwareSerial Serial2;
|
2013-12-01 08:21:54 -08:00
|
|
|
#define HAVE_HWSERIAL2
|
2010-10-17 10:36:02 -07:00
|
|
|
#endif
|
|
|
|
#if defined(UBRR3H)
|
|
|
|
extern HardwareSerial Serial3;
|
2013-12-01 08:21:54 -08:00
|
|
|
#define HAVE_HWSERIAL3
|
2009-06-01 01:32:11 -07:00
|
|
|
#endif
|
|
|
|
|
2011-10-27 08:45:13 -07:00
|
|
|
extern void serialEventRun(void) __attribute__((weak));
|
|
|
|
|
2009-06-01 01:32:11 -07:00
|
|
|
#endif
|