2009-06-01 01:32:11 -07:00
|
|
|
/*
|
|
|
|
HardwareSerial.cpp - 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
|
|
|
|
|
|
|
|
Modified 23 November 2006 by David A. Mellis
|
2010-10-17 10:36:02 -07:00
|
|
|
Modified 28 September 2010 by Mark Sproul
|
2012-08-14 06:50:36 -07:00
|
|
|
Modified 14 August 2012 by Alarus
|
2009-06-01 01:32:11 -07:00
|
|
|
*/
|
|
|
|
|
2010-07-04 16:22:34 -07:00
|
|
|
#include <stdlib.h>
|
2009-06-01 01:32:11 -07:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <inttypes.h>
|
2011-03-01 17:00:16 -08:00
|
|
|
#include "Arduino.h"
|
2009-06-01 01:32:11 -07:00
|
|
|
#include "wiring_private.h"
|
|
|
|
|
2013-12-01 08:21:54 -08:00
|
|
|
#include "HardwareSerial.h"
|
|
|
|
|
2010-10-17 10:36:02 -07:00
|
|
|
// this next line disables the entire HardwareSerial.cpp,
|
|
|
|
// this is so I can support Attiny series and any other chip without a uart
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL0) || defined(HAVE_HWSERIAL1) || defined(HAVE_HWSERIAL2) || defined(HAVE_HWSERIAL3)
|
2009-06-01 01:32:11 -07:00
|
|
|
|
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
|
|
|
// Ensure that the various bit positions we use are available with a 0
|
|
|
|
// postfix, so we can always use the values for UART0 for all UARTs. The
|
|
|
|
// alternative, passing the various values for each UART to the
|
|
|
|
// HardwareSerial constructor also works, but makes the code bigger and
|
|
|
|
// slower.
|
2012-11-29 10:48:01 -08:00
|
|
|
#if !defined(TXC0)
|
|
|
|
#if defined(TXC)
|
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
|
|
|
// On ATmega8, the uart and its bits are not numbered, so there is no TXC0 etc.
|
2012-11-29 10:48:01 -08:00
|
|
|
#define TXC0 TXC
|
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
|
|
|
#define RXEN0 RXEN
|
|
|
|
#define TXEN0 TXEN
|
|
|
|
#define RXCIE0 RXCIE
|
|
|
|
#define UDRIE0 UDRIE
|
|
|
|
#define U2X0 U2X
|
|
|
|
#define UPE0 UPE
|
|
|
|
#define UDRE0 UDRE
|
2012-11-29 10:48:01 -08:00
|
|
|
#elif defined(TXC1)
|
|
|
|
// Some devices have uart1 but no uart0
|
|
|
|
#define TXC0 TXC1
|
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
|
|
|
#define RXEN0 RXEN1
|
|
|
|
#define TXEN0 TXEN1
|
|
|
|
#define RXCIE0 RXCIE1
|
|
|
|
#define UDRIE0 UDRIE1
|
|
|
|
#define U2X0 U2X1
|
|
|
|
#define UPE0 UPE1
|
|
|
|
#define UDRE0 UDRE1
|
2012-11-29 10:48:01 -08:00
|
|
|
#else
|
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
|
|
|
#error No UART found in HardwareSerial.cpp
|
|
|
|
#endif
|
|
|
|
#endif // !defined TXC0
|
|
|
|
|
|
|
|
// Check at compiletime that it is really ok to use the bit positions of
|
|
|
|
// UART0 for the other UARTs as well, in case these values ever get
|
|
|
|
// changed for future hardware.
|
|
|
|
#if defined(TXC1) && (TXC1 != TXC0 || RXEN1 != RXEN0 || RXCIE1 != RXCIE0 || \
|
|
|
|
UDRIE1 != UDRIE0 || U2X1 != U2X0 || UPE1 != UPE0 || \
|
|
|
|
UDRE1 != UDRE0)
|
|
|
|
#error "Not all bit positions for UART1 are the same as for UART0"
|
|
|
|
#endif
|
|
|
|
#if defined(TXC2) && (TXC2 != TXC0 || RXEN2 != RXEN0 || RXCIE2 != RXCIE0 || \
|
|
|
|
UDRIE2 != UDRIE0 || U2X2 != U2X0 || UPE2 != UPE0 || \
|
|
|
|
UDRE2 != UDRE0)
|
|
|
|
#error "Not all bit positions for UART2 are the same as for UART0"
|
2012-11-29 10:48:01 -08:00
|
|
|
#endif
|
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
|
|
|
#if defined(TXC3) && (TXC3 != TXC0 || RXEN3 != RXEN0 || RXCIE3 != RXCIE0 || \
|
|
|
|
UDRIE3 != UDRIE0 || U3X3 != U3X0 || UPE3 != UPE0 || \
|
|
|
|
UDRE3 != UDRE0)
|
|
|
|
#error "Not all bit positions for UART3 are the same as for UART0"
|
2012-11-29 10:48:01 -08:00
|
|
|
#endif
|
|
|
|
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL0)
|
2011-05-07 10:04:13 -07:00
|
|
|
void serialEvent() __attribute__((weak));
|
|
|
|
void serialEvent() {}
|
2010-10-17 10:36:02 -07:00
|
|
|
#if defined(USART_RX_vect)
|
2013-03-29 06:41:36 -07:00
|
|
|
ISR(USART_RX_vect)
|
2010-10-17 10:36:02 -07:00
|
|
|
#elif defined(USART0_RX_vect)
|
2013-03-29 06:41:36 -07:00
|
|
|
ISR(USART0_RX_vect)
|
2013-03-29 07:17:54 -07:00
|
|
|
#elif defined(USART_RXC_vect)
|
|
|
|
ISR(USART_RXC_vect) // ATmega8
|
2013-12-01 08:21:54 -08:00
|
|
|
#else
|
|
|
|
#error "Don't know what the Data Received vector is called for the first UART"
|
2011-05-07 09:47:43 -07:00
|
|
|
#endif
|
2010-10-17 10:36:02 -07:00
|
|
|
{
|
2013-04-18 02:38:13 -07:00
|
|
|
Serial._rx_complete_irq();
|
2010-10-17 10:36:02 -07:00
|
|
|
}
|
|
|
|
#endif
|
2009-06-01 01:32:11 -07:00
|
|
|
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL1)
|
2011-05-07 10:04:13 -07:00
|
|
|
void serialEvent1() __attribute__((weak));
|
|
|
|
void serialEvent1() {}
|
2013-03-29 06:41:36 -07:00
|
|
|
ISR(USART1_RX_vect)
|
2010-10-17 10:36:02 -07:00
|
|
|
{
|
2013-04-18 02:38:13 -07:00
|
|
|
Serial1._rx_complete_irq();
|
2010-10-17 10:36:02 -07:00
|
|
|
}
|
2009-06-01 01:32:11 -07:00
|
|
|
#endif
|
2010-10-17 10:36:02 -07:00
|
|
|
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL2)
|
2011-05-07 10:04:13 -07:00
|
|
|
void serialEvent2() __attribute__((weak));
|
|
|
|
void serialEvent2() {}
|
2013-03-29 06:41:36 -07:00
|
|
|
ISR(USART2_RX_vect)
|
2010-10-17 10:36:02 -07:00
|
|
|
{
|
2013-04-18 02:38:13 -07:00
|
|
|
Serial2._rx_complete_irq();
|
2010-10-17 10:36:02 -07:00
|
|
|
}
|
2009-06-01 01:32:11 -07:00
|
|
|
#endif
|
|
|
|
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL3)
|
2011-05-07 10:04:13 -07:00
|
|
|
void serialEvent3() __attribute__((weak));
|
|
|
|
void serialEvent3() {}
|
2013-03-29 06:41:36 -07:00
|
|
|
ISR(USART3_RX_vect)
|
2010-10-17 10:36:02 -07:00
|
|
|
{
|
2013-04-18 02:38:13 -07:00
|
|
|
Serial3._rx_complete_irq();
|
2010-10-17 10:36:02 -07:00
|
|
|
}
|
2009-06-01 01:32:11 -07:00
|
|
|
#endif
|
|
|
|
|
2011-08-31 12:52:56 -07:00
|
|
|
void serialEventRun(void)
|
|
|
|
{
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL0)
|
2011-09-07 14:47:17 -07:00
|
|
|
if (Serial.available()) serialEvent();
|
2011-08-31 12:52:56 -07:00
|
|
|
#endif
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL1)
|
2011-09-07 14:47:17 -07:00
|
|
|
if (Serial1.available()) serialEvent1();
|
2011-08-31 12:52:56 -07:00
|
|
|
#endif
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL2)
|
2011-09-07 14:47:17 -07:00
|
|
|
if (Serial2.available()) serialEvent2();
|
2011-08-31 12:52:56 -07:00
|
|
|
#endif
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL3)
|
2011-09-07 14:47:17 -07:00
|
|
|
if (Serial3.available()) serialEvent3();
|
2011-08-31 12:52:56 -07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2010-10-17 10:36:02 -07:00
|
|
|
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL0)
|
2011-03-05 11:17:26 -08:00
|
|
|
#if defined(UART0_UDRE_vect)
|
|
|
|
ISR(UART0_UDRE_vect)
|
|
|
|
#elif defined(UART_UDRE_vect)
|
|
|
|
ISR(UART_UDRE_vect)
|
|
|
|
#elif defined(USART0_UDRE_vect)
|
|
|
|
ISR(USART0_UDRE_vect)
|
|
|
|
#elif defined(USART_UDRE_vect)
|
|
|
|
ISR(USART_UDRE_vect)
|
2013-12-01 08:21:54 -08:00
|
|
|
#else
|
|
|
|
#error "Don't know what the Data Register Empty vector is called for the first UART"
|
2011-03-05 11:17:26 -08:00
|
|
|
#endif
|
|
|
|
{
|
2013-04-18 02:38:13 -07:00
|
|
|
Serial._tx_udr_empty_irq();
|
2011-03-05 11:17:26 -08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL1)
|
2011-03-05 11:17:26 -08:00
|
|
|
ISR(USART1_UDRE_vect)
|
|
|
|
{
|
2013-04-18 02:38:13 -07:00
|
|
|
Serial1._tx_udr_empty_irq();
|
2011-03-05 11:17:26 -08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL2)
|
2011-03-05 11:17:26 -08:00
|
|
|
ISR(USART2_UDRE_vect)
|
|
|
|
{
|
2013-04-18 02:38:13 -07:00
|
|
|
Serial2._tx_udr_empty_irq();
|
2011-03-05 11:17:26 -08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL3)
|
2011-03-05 11:17:26 -08:00
|
|
|
ISR(USART3_UDRE_vect)
|
|
|
|
{
|
2013-04-18 02:38:13 -07:00
|
|
|
Serial3._tx_udr_empty_irq();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
// Actual interrupt handlers //////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
void HardwareSerial::_rx_complete_irq(void)
|
|
|
|
{
|
|
|
|
if (bit_is_clear(*_ucsra, UPE0)) {
|
|
|
|
// No Parity error, read byte and store it in the buffer if there is
|
|
|
|
// room
|
|
|
|
unsigned char c = *_udr;
|
|
|
|
int i = (unsigned int)(_rx_buffer_head + 1) % SERIAL_BUFFER_SIZE;
|
|
|
|
|
|
|
|
// if we should be storing the received character into the location
|
|
|
|
// just before the tail (meaning that the head would advance to the
|
|
|
|
// current location of the tail), we're about to overflow the buffer
|
|
|
|
// and so we don't write the character or advance the head.
|
|
|
|
if (i != _rx_buffer_tail) {
|
|
|
|
_rx_buffer[_rx_buffer_head] = c;
|
|
|
|
_rx_buffer_head = i;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Parity error, read byte but discard it
|
|
|
|
unsigned char c = *_udr;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
void HardwareSerial::_tx_udr_empty_irq(void)
|
|
|
|
{
|
2013-04-18 10:06:00 -07:00
|
|
|
// If interrupts are enabled, there must be more data in the output
|
|
|
|
// buffer. Send the next byte
|
|
|
|
unsigned char c = _tx_buffer[_tx_buffer_tail];
|
|
|
|
_tx_buffer_tail = (_tx_buffer_tail + 1) % SERIAL_BUFFER_SIZE;
|
|
|
|
|
|
|
|
*_udr = c;
|
|
|
|
|
|
|
|
// clear the TXC bit -- "can be cleared by writing a one to its bit
|
|
|
|
// location". This makes sure flush() won't return until the bytes
|
|
|
|
// actually got written
|
|
|
|
sbi(*_ucsra, TXC0);
|
|
|
|
|
2013-04-18 02:38:13 -07:00
|
|
|
if (_tx_buffer_head == _tx_buffer_tail) {
|
|
|
|
// Buffer empty, so disable interrupts
|
|
|
|
cbi(*_ucsrb, UDRIE0);
|
2011-03-05 11:17:26 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-01 01:32:11 -07:00
|
|
|
// Constructors ////////////////////////////////////////////////////////////////
|
|
|
|
|
2013-04-18 09:52:48 -07:00
|
|
|
HardwareSerial::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)
|
2009-06-01 01:32:11 -07:00
|
|
|
{
|
2013-04-18 09:52:48 -07:00
|
|
|
_tx_buffer_head = _tx_buffer_tail = 0;
|
|
|
|
_rx_buffer_head = _rx_buffer_tail = 0;
|
2009-06-01 01:32:11 -07:00
|
|
|
_ubrrh = ubrrh;
|
|
|
|
_ubrrl = ubrrl;
|
|
|
|
_ucsra = ucsra;
|
|
|
|
_ucsrb = ucsrb;
|
2012-08-12 07:57:57 -07:00
|
|
|
_ucsrc = ucsrc;
|
2009-06-01 01:32:11 -07:00
|
|
|
_udr = udr;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Public Methods //////////////////////////////////////////////////////////////
|
|
|
|
|
2012-08-14 06:50:36 -07:00
|
|
|
void HardwareSerial::begin(unsigned long baud, byte config)
|
2012-08-12 07:57:57 -07:00
|
|
|
{
|
2013-04-19 07:32:33 -07:00
|
|
|
// Try u2x mode first
|
|
|
|
uint16_t baud_setting = (F_CPU / 4 / baud - 1) / 2;
|
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
|
|
|
*_ucsra = 1 << U2X0;
|
2012-08-12 07:57:57 -07:00
|
|
|
|
2013-04-19 07:32:33 -07:00
|
|
|
// hardcoded exception for 57600 for compatibility with the bootloader
|
|
|
|
// shipped with the Duemilanove and previous boards and the firmware
|
|
|
|
// on the 8U2 on the Uno and Mega 2560. Also, The baud_setting cannot
|
|
|
|
// be > 4095, so switch back to non-u2x mode if the baud rate is too
|
|
|
|
// low.
|
|
|
|
if (((F_CPU == 16000000UL) && (baud == 57600)) || (baud_setting >4095))
|
|
|
|
{
|
2012-08-12 07:57:57 -07:00
|
|
|
*_ucsra = 0;
|
|
|
|
baud_setting = (F_CPU / 8 / baud - 1) / 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
// assign the baud_setting, a.k.a. ubbr (USART Baud Rate Register)
|
|
|
|
*_ubrrh = baud_setting >> 8;
|
|
|
|
*_ubrrl = baud_setting;
|
|
|
|
|
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
|
|
|
_written = false;
|
|
|
|
|
2012-08-30 05:47:35 -07:00
|
|
|
//set the data bits, parity, and stop bits
|
|
|
|
#if defined(__AVR_ATmega8__)
|
|
|
|
config |= 0x80; // select UCSRC register (shared with UBRRH)
|
|
|
|
#endif
|
|
|
|
*_ucsrc = config;
|
2012-08-12 07:57:57 -07:00
|
|
|
|
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
|
|
|
sbi(*_ucsrb, RXEN0);
|
|
|
|
sbi(*_ucsrb, TXEN0);
|
|
|
|
sbi(*_ucsrb, RXCIE0);
|
|
|
|
cbi(*_ucsrb, UDRIE0);
|
2012-08-12 07:57:57 -07:00
|
|
|
}
|
|
|
|
|
2009-12-22 16:00:17 -08:00
|
|
|
void HardwareSerial::end()
|
|
|
|
{
|
2011-03-06 09:20:42 -08:00
|
|
|
// wait for transmission of outgoing data
|
2013-04-18 09:52:48 -07:00
|
|
|
while (_tx_buffer_head != _tx_buffer_tail)
|
2011-03-06 09:20:42 -08:00
|
|
|
;
|
|
|
|
|
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
|
|
|
cbi(*_ucsrb, RXEN0);
|
|
|
|
cbi(*_ucsrb, TXEN0);
|
|
|
|
cbi(*_ucsrb, RXCIE0);
|
|
|
|
cbi(*_ucsrb, UDRIE0);
|
2011-03-06 09:20:42 -08:00
|
|
|
|
|
|
|
// clear any received data
|
2013-04-18 09:52:48 -07:00
|
|
|
_rx_buffer_head = _rx_buffer_tail;
|
2009-12-22 16:00:17 -08:00
|
|
|
}
|
|
|
|
|
2010-08-02 15:23:48 -07:00
|
|
|
int HardwareSerial::available(void)
|
2009-06-01 01:32:11 -07:00
|
|
|
{
|
2013-04-18 09:52:48 -07:00
|
|
|
return (unsigned int)(SERIAL_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail) % SERIAL_BUFFER_SIZE;
|
2009-06-01 01:32:11 -07:00
|
|
|
}
|
|
|
|
|
2010-07-04 16:31:55 -07:00
|
|
|
int HardwareSerial::peek(void)
|
|
|
|
{
|
2013-04-18 09:52:48 -07:00
|
|
|
if (_rx_buffer_head == _rx_buffer_tail) {
|
2010-07-04 16:31:55 -07:00
|
|
|
return -1;
|
|
|
|
} else {
|
2013-04-18 09:52:48 -07:00
|
|
|
return _rx_buffer[_rx_buffer_tail];
|
2010-07-04 16:31:55 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-01 01:32:11 -07:00
|
|
|
int HardwareSerial::read(void)
|
|
|
|
{
|
2009-07-11 18:58:15 -07:00
|
|
|
// if the head isn't ahead of the tail, we don't have any characters
|
2013-04-18 09:52:48 -07:00
|
|
|
if (_rx_buffer_head == _rx_buffer_tail) {
|
2009-07-11 18:58:15 -07:00
|
|
|
return -1;
|
|
|
|
} else {
|
2013-04-18 09:52:48 -07:00
|
|
|
unsigned char c = _rx_buffer[_rx_buffer_tail];
|
|
|
|
_rx_buffer_tail = (unsigned int)(_rx_buffer_tail + 1) % SERIAL_BUFFER_SIZE;
|
2009-07-11 18:58:15 -07:00
|
|
|
return c;
|
|
|
|
}
|
2009-06-01 01:32:11 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void HardwareSerial::flush()
|
|
|
|
{
|
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
|
|
|
// If we have never written a byte, no need to flush. This special
|
|
|
|
// case is needed since there is no way to force the TXC (transmit
|
|
|
|
// complete) bit to 1 during initialization
|
|
|
|
if (!_written)
|
|
|
|
return;
|
|
|
|
|
2013-04-18 12:34:00 -07:00
|
|
|
while (bit_is_set(*_ucsrb, UDRIE0) || bit_is_clear(*_ucsra, TXC0)) {
|
|
|
|
if (bit_is_clear(SREG, SREG_I) && bit_is_set(*_ucsrb, UDRIE0))
|
|
|
|
// Interrupts are globally disabled, but the DR empty
|
|
|
|
// interrupt should be enabled, so poll the DR empty flag to
|
|
|
|
// prevent deadlock
|
|
|
|
if (bit_is_set(*_ucsra, UDRE0))
|
|
|
|
_tx_udr_empty_irq();
|
|
|
|
}
|
Fix HardwareSerial::flush() when interrupts are kept disabled for a while
It turns out there is an additional corner case. The analysis in the
previous commit wrt to flush() assumes that the data register is always
kept filled by the interrupt handler, so the TXC bit won't get set until
all the queued bytes have been transmitted. But, when interrupts are
disabled for a longer period (for example when an interrupt handler for
another device is running for longer than 1-2 byte times), it could
happen that the UART stops transmitting while there are still more bytes
queued (but these are in the buffer, not in the UDR register, so the
UART can't know about them).
In this case, the TXC bit would get set, but the transmission is not
complete yet. We can easily detect this case by looking at the head and
tail pointers, but it seems easier to instead look at the UDRIE bit
(the TX interrupt is enabled if and only if there are bytes in the
queue). To fix this corner case, this commit:
- Checks the UDRIE bit and only if it is unset, looks at the TXC bit.
- Moves the clearing of TXC from write() to the tx interrupt handler.
This (still) causes the TXC bit to be cleared whenever a byte is
queued when the buffer is empty (in this case the tx interrupt will
trigger directly after write() is called). It also causes the TXC bit
to be cleared whenever transmission is resumed after it halted
because interrupts have been disabled for too long.
As a side effect, another race condition is prevented. This could occur
at very high bitrates, where the transmission would be completed before
the code got time to clear the TXC0 register, making the clear happen
_after_ the transmission was already complete. With the new code, the
clearing of TXC happens directly after writing to the UDR register,
while interrupts are disabled, and we can be certain the data
transmission needs more time than one instruction to complete. This
fixes #1463 and replaces #1456.
2013-04-19 03:56:54 -07:00
|
|
|
// If we get here, nothing is queued anymore (DRIE is disabled) and
|
|
|
|
// the hardware finished tranmission (TXC is set).
|
2009-06-01 01:32:11 -07:00
|
|
|
}
|
|
|
|
|
2011-08-26 13:08:14 -07:00
|
|
|
size_t HardwareSerial::write(uint8_t c)
|
2009-06-01 01:32:11 -07:00
|
|
|
{
|
2013-04-18 09:52:48 -07:00
|
|
|
int i = (_tx_buffer_head + 1) % SERIAL_BUFFER_SIZE;
|
2011-03-05 11:17:26 -08:00
|
|
|
|
|
|
|
// If the output buffer is full, there's nothing for it other than to
|
|
|
|
// wait for the interrupt handler to empty it a bit
|
2013-04-18 12:34:00 -07:00
|
|
|
while (i == _tx_buffer_tail) {
|
|
|
|
if (bit_is_clear(SREG, SREG_I)) {
|
|
|
|
// Interrupts are disabled, so we'll have to poll the data
|
|
|
|
// register empty flag ourselves. If it is set, pretend an
|
|
|
|
// interrupt has happened and call the handler to free up
|
|
|
|
// space for us.
|
|
|
|
if(bit_is_set(*_ucsra, UDRE0))
|
|
|
|
_tx_udr_empty_irq();
|
|
|
|
} else {
|
|
|
|
// nop, the interrupt handler will free up space for us
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-18 09:52:48 -07:00
|
|
|
_tx_buffer[_tx_buffer_head] = c;
|
|
|
|
_tx_buffer_head = i;
|
2011-03-05 11:17:26 -08:00
|
|
|
|
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
|
|
|
sbi(*_ucsrb, UDRIE0);
|
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
|
|
|
_written = true;
|
2011-08-23 16:12:03 -07:00
|
|
|
|
|
|
|
return 1;
|
2009-06-01 01:32:11 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// Preinstantiate Objects //////////////////////////////////////////////////////
|
|
|
|
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL0)
|
2010-10-17 10:36:02 -07:00
|
|
|
#if defined(UBRRH) && defined(UBRRL)
|
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
|
|
|
HardwareSerial Serial(&UBRRH, &UBRRL, &UCSRA, &UCSRB, &UCSRC, &UDR);
|
2009-06-01 01:32:11 -07:00
|
|
|
#else
|
2013-12-01 08:21:54 -08:00
|
|
|
HardwareSerial Serial(&UBRR0H, &UBRR0L, &UCSR0A, &UCSR0B, &UCSR0C, &UDR0);
|
|
|
|
#endif
|
2009-06-01 01:32:11 -07:00
|
|
|
#endif
|
|
|
|
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL1)
|
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
|
|
|
HardwareSerial Serial1(&UBRR1H, &UBRR1L, &UCSR1A, &UCSR1B, &UCSR1C, &UDR1);
|
2010-10-17 10:36:02 -07:00
|
|
|
#endif
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL2)
|
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
|
|
|
HardwareSerial Serial2(&UBRR2H, &UBRR2L, &UCSR2A, &UCSR2B, &UCSR2C, &UDR2);
|
2010-10-17 10:36:02 -07:00
|
|
|
#endif
|
2013-12-01 08:21:54 -08:00
|
|
|
#if defined(HAVE_HWSERIAL3)
|
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
|
|
|
HardwareSerial Serial3(&UBRR3H, &UBRR3L, &UCSR3A, &UCSR3B, &UCSR3C, &UDR3);
|
2009-06-01 01:32:11 -07:00
|
|
|
#endif
|
2010-10-17 10:36:02 -07:00
|
|
|
|
|
|
|
#endif // whole file
|
|
|
|
|