Skip to content

Changes from cpu based #ifdefs to register based #ifdefs #7

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 9 commits into from
Closed

Changes from cpu based #ifdefs to register based #ifdefs #7

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
7aed6f3
Using register #ifdefs instead of cpu #ifdefs
Oct 1, 2010
0778700
Changed from cpu #ifdefs to register #ifdefs
Oct 1, 2010
202e074
Changed from cpu #ifdefs to register #ifdefs
Oct 1, 2010
c692793
changed from cpu #ifdefs to register #ifdefs
Oct 1, 2010
9901d40
Merge remote branch 'upstream/master'
Oct 3, 2010
9c9e408
Merge branch 'master' of http://github.com/arduino/Arduino
Oct 5, 2010
803593d
Changes to use register #ifdefs instead of cpu #ifdefs
Oct 6, 2010
f26bf31
syncing commits
Oct 10, 2010
5e9dcff
issue 392 bug with git status! in code
Nov 11, 2010
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
183 changes: 142 additions & 41 deletions hardware/arduino/bootloaders/stk500v2/stk500boot.c
View file
Open in desktop

Large diffs are not rendered by default.

1,015 changes: 508 additions & 507 deletions hardware/arduino/bootloaders/stk500v2/stk500boot_v2_mega2560.hex
View file
Open in desktop

Large diffs are not rendered by default.

198 changes: 154 additions & 44 deletions hardware/arduino/cores/arduino/HardwareSerial.cpp
100755 → 100644
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,18 @@

Modified 23 November 2006 by David A. Mellis
*/
//*******************************************************************************************
//* Mar 14, 2010 <MLS> Mark Sproul fixed bug in __AVR_ATmega644__ interrupt vector
//* Mar 25, 2010 <MLS> Fixed bug in __AVR_ATmega644P__ interrupt vector
//* Apr 2, 2010 <MLS> Changed RX_BUFFER_SIZE to 32 for smaller ram processors
//* Jul 30, 2010 <MLS> Chainging #ifdefs to register and signals instead of CPU type
//* Aug 3, 2010 <MLS> Tested on 644P 645 1280, 2560 328 and others
//* Aug 16, 2010 <MLS> Added support for Atmega32
//* Aug 31, 2010 <MLS> The ATmega32U4 has uart1 but NOT uart0
//* Sep 5, 2010 <MLS> V0019 was released, migrated changes into 0019
//* Sep 28, 2010 <MLS> V0020 was released, migrated changes into 0020
//* Oct 1, 2010 <MLS> Added more constraints to handle atmega128rfa1
//*******************************************************************************************

#include <stdlib.h>
#include <stdio.h>
Expand All @@ -26,28 +38,46 @@
#include "wiring.h"
#include "wiring_private.h"

//*******************************************************************************************
//* this next line disables the entire HardwareSerial.cpp,
//* this is so I can support Attiny series and any other chip without a uart
#if defined(UBRRH) || defined(UBRR0H) || defined(UBRR1H) || defined(UBRR2H) || defined(UBRR3H)

#include "HardwareSerial.h"

// Define constants and variables for buffering incoming serial data. We're
// using a ring buffer (I think), in which rx_buffer_head is the index of the
// location to which to write the next incoming character and rx_buffer_tail
// is the index of the location from which to read.
#define RX_BUFFER_SIZE 128
#if (RAMEND < 1500)
#define RX_BUFFER_SIZE 32
#else
#define RX_BUFFER_SIZE 128
#endif

struct ring_buffer {
unsigned char buffer[RX_BUFFER_SIZE];
int head;
int tail;
struct ring_buffer
{
unsigned char buffer[RX_BUFFER_SIZE];
int head;
int tail;
};

ring_buffer rx_buffer = { { 0 }, 0, 0 };
#if defined(UBRRH) || defined(UBRR0H)
ring_buffer rx_buffer = { { 0 }, 0, 0 };
#endif

#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
ring_buffer rx_buffer1 = { { 0 }, 0, 0 };
ring_buffer rx_buffer2 = { { 0 }, 0, 0 };
ring_buffer rx_buffer3 = { { 0 }, 0, 0 };
//#if defined(__AVR_ATmega1280__)
#if defined(UBRR1H)
ring_buffer rx_buffer1 = { { 0 }, 0, 0 };
#endif
#if defined(UBRR2H)
ring_buffer rx_buffer2 = { { 0 }, 0, 0 };
#endif
#if defined(UBRR3H)
ring_buffer rx_buffer3 = { { 0 }, 0, 0 };
#endif

//*******************************************************************************************
inline void store_char(unsigned char c, ring_buffer *rx_buffer)
{
int i = (rx_buffer->head + 1) % RX_BUFFER_SIZE;
Expand All @@ -62,52 +92,112 @@ inline void store_char(unsigned char c, ring_buffer *rx_buffer)
}
}

#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)

SIGNAL(SIG_USART0_RECV)
#if defined(USART_RX_vect)
//*******************************************************************************************
SIGNAL(USART_RX_vect)
{
unsigned char c = UDR0;
store_char(c, &rx_buffer);
#if defined(UDR0)
unsigned char c = UDR0;
#elif defined(UDR)
unsigned char c = UDR; // atmega8535
#else
#error UDR not defined
#endif
store_char(c, &rx_buffer);
}

SIGNAL(SIG_USART1_RECV)
#elif defined(SIG_USART0_RECV) && defined(UDR0)
//*******************************************************************************************
SIGNAL(SIG_USART0_RECV)
{
unsigned char c = UDR1;
store_char(c, &rx_buffer1);
unsigned char c = UDR0;
store_char(c, &rx_buffer);
}

SIGNAL(SIG_USART2_RECV)
#elif defined(SIG_UART0_RECV) && defined(UDR0)
//*******************************************************************************************
SIGNAL(SIG_UART0_RECV)
{
unsigned char c = UDR2;
store_char(c, &rx_buffer2);
unsigned char c = UDR0;
store_char(c, &rx_buffer);
}

SIGNAL(SIG_USART3_RECV)
//#elif defined(SIG_USART_RECV)
#elif defined(USART0_RX_vect)
//*******************************************************************************************
//* fixed by Mark Sproul March 25, 2010
//* this is on the 644/644p
//SIGNAL(SIG_USART_RECV)
SIGNAL(USART0_RX_vect)
{
unsigned char c = UDR3;
store_char(c, &rx_buffer3);
}

#if defined(UDR0)
unsigned char c = UDR0;
#elif defined(UDR)
unsigned char c = UDR; // atmega8, atmega32
#else

#if defined(__AVR_ATmega8__)
#error UDR not defined
#endif
store_char(c, &rx_buffer);
}
#elif defined(SIG_UART_RECV)
//*******************************************************************************************
//* this is for atmega8
SIGNAL(SIG_UART_RECV)
{
#if defined(UDR0)
unsigned char c = UDR0; // atmega645
#elif defined(UDR)
unsigned char c = UDR; // atmega8
#endif

store_char(c, &rx_buffer);
}
#elif defined(USBCON)
#warning No interrupt handler for usart 0
#warning Serial(0) is on USB interface
#else
SIGNAL(USART_RX_vect)
#error No interrupt handler for usart 0
#endif

//#if defined(SIG_USART1_RECV)
#if defined(USART1_RX_vect)
//*******************************************************************************************
//SIGNAL(SIG_USART1_RECV)
SIGNAL(USART1_RX_vect)
{
#if defined(__AVR_ATmega8__)
unsigned char c = UDR;
#else
unsigned char c = UDR0;
unsigned char c = UDR1;
store_char(c, &rx_buffer1);
}
#elif defined(SIG_USART1_RECV)
#error SIG_USART1_RECV
#endif
store_char(c, &rx_buffer);


//#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#if defined(USART2_RX_vect) && defined(UDR2)
//*******************************************************************************************
SIGNAL(USART2_RX_vect)
{
unsigned char c = UDR2;
store_char(c, &rx_buffer2);
}
#elif defined(SIG_USART2_RECV)
#error SIG_USART2_RECV
#endif

#if defined(USART3_RX_vect) && defined(UDR3)
//*******************************************************************************************
SIGNAL(USART3_RX_vect)
{
unsigned char c = UDR3;
store_char(c, &rx_buffer3);
}
#elif defined(SIG_USART3_RECV)
#error SIG_USART3_RECV
#endif



// Constructors ////////////////////////////////////////////////////////////////

//*******************************************************************************************
HardwareSerial::HardwareSerial(ring_buffer *rx_buffer,
volatile uint8_t *ubrrh, volatile uint8_t *ubrrl,
volatile uint8_t *ucsra, volatile uint8_t *ucsrb,
Expand All @@ -129,6 +219,7 @@ HardwareSerial::HardwareSerial(ring_buffer *rx_buffer,

// Public Methods //////////////////////////////////////////////////////////////

//*******************************************************************************************
void HardwareSerial::begin(long baud)
{
uint16_t baud_setting;
Expand Down Expand Up @@ -166,18 +257,21 @@ void HardwareSerial::begin(long baud)
sbi(*_ucsrb, _rxcie);
}

//*******************************************************************************************
void HardwareSerial::end()
{
cbi(*_ucsrb, _rxen);
cbi(*_ucsrb, _txen);
cbi(*_ucsrb, _rxcie);
}

//*******************************************************************************************
int HardwareSerial::available(void)
{
return (RX_BUFFER_SIZE + _rx_buffer->head - _rx_buffer->tail) % RX_BUFFER_SIZE;
}

//*******************************************************************************************
int HardwareSerial::peek(void)
{
if (_rx_buffer->head == _rx_buffer->tail) {
Expand All @@ -187,6 +281,7 @@ int HardwareSerial::peek(void)
}
}

//*******************************************************************************************
int HardwareSerial::read(void)
{
// if the head isn't ahead of the tail, we don't have any characters
Expand All @@ -199,6 +294,7 @@ int HardwareSerial::read(void)
}
}

//*******************************************************************************************
void HardwareSerial::flush()
{
// don't reverse this or there may be problems if the RX interrupt
Expand All @@ -213,6 +309,7 @@ void HardwareSerial::flush()
_rx_buffer->head = _rx_buffer->tail;
}

//*******************************************************************************************
void HardwareSerial::write(uint8_t c)
{
while (!((*_ucsra) & (1 << _udre)))
Expand All @@ -223,14 +320,27 @@ void HardwareSerial::write(uint8_t c)

// Preinstantiate Objects //////////////////////////////////////////////////////

#if defined(__AVR_ATmega8__)
HardwareSerial Serial(&rx_buffer, &UBRRH, &UBRRL, &UCSRA, &UCSRB, &UDR, RXEN, TXEN, RXCIE, UDRE, U2X);
//#if defined(__AVR_ATmega8__)
#if defined(UBRRH) && defined(UBRRL)
HardwareSerial Serial(&rx_buffer, &UBRRH, &UBRRL, &UCSRA, &UCSRB, &UDR, RXEN, TXEN, RXCIE, UDRE, U2X);
#elif defined(UBRR0H) && defined(UBRR0L)
HardwareSerial Serial(&rx_buffer, &UBRR0H, &UBRR0L, &UCSR0A, &UCSR0B, &UDR0, RXEN0, TXEN0, RXCIE0, UDRE0, U2X0);
#elif defined(USBCON)
#warning no serial port defined (port 0)
#else
HardwareSerial Serial(&rx_buffer, &UBRR0H, &UBRR0L, &UCSR0A, &UCSR0B, &UDR0, RXEN0, TXEN0, RXCIE0, UDRE0, U2X0);
#error no serial port defined (port 0)
#endif

#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
HardwareSerial Serial1(&rx_buffer1, &UBRR1H, &UBRR1L, &UCSR1A, &UCSR1B, &UDR1, RXEN1, TXEN1, RXCIE1, UDRE1, U2X1);
HardwareSerial Serial2(&rx_buffer2, &UBRR2H, &UBRR2L, &UCSR2A, &UCSR2B, &UDR2, RXEN2, TXEN2, RXCIE2, UDRE2, U2X2);
HardwareSerial Serial3(&rx_buffer3, &UBRR3H, &UBRR3L, &UCSR3A, &UCSR3B, &UDR3, RXEN3, TXEN3, RXCIE3, UDRE3, U2X3);
//#if defined(__AVR_ATmega1280__)
#if defined(UBRR1H)
HardwareSerial Serial1(&rx_buffer1, &UBRR1H, &UBRR1L, &UCSR1A, &UCSR1B, &UDR1, RXEN1, TXEN1, RXCIE1, UDRE1, U2X1);
#endif
#if defined(UBRR2H)
HardwareSerial Serial2(&rx_buffer2, &UBRR2H, &UBRR2L, &UCSR2A, &UCSR2B, &UDR2, RXEN2, TXEN2, RXCIE2, UDRE2, U2X2);
#endif
#if defined(UBRR3H)
HardwareSerial Serial3(&rx_buffer3, &UBRR3H, &UBRR3L, &UCSR3A, &UCSR3B, &UDR3, RXEN3, TXEN3, RXCIE3, UDRE3, U2X3);
#endif


#endif //defined(UBRRH) || defined(UBRR0H) || defined(UBRR1H) || defined(UBRR2H) || defined(UBRR3H)
22 changes: 17 additions & 5 deletions hardware/arduino/cores/arduino/HardwareSerial.h
100755 → 100644
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,6 +16,9 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
//*******************************************************************************************
//* Sep 28, 2010 <MLS> V0020 was released, migrated changes into 0020
//*******************************************************************************************

#ifndef HardwareSerial_h
#define HardwareSerial_h
Expand Down Expand Up @@ -56,12 +59,21 @@ class HardwareSerial : public Stream
using Print::write; // pull in write(str) and write(buf, size) from Print
};

extern HardwareSerial Serial;
#if defined(UBRRH) || defined(UBRR0H)
extern HardwareSerial Serial;
#elif defined(USBCON)
#include "usb_api.h"
#endif

#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
extern HardwareSerial Serial1;
extern HardwareSerial Serial2;
extern HardwareSerial Serial3;
//#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#if defined(UBRR1H)
extern HardwareSerial Serial1;
#endif
#if defined(UBRR2H)
extern HardwareSerial Serial2;
#endif
#if defined(UBRR3H)
extern HardwareSerial Serial3;
#endif

#endif
29 changes: 29 additions & 0 deletions hardware/arduino/cores/arduino/Print.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,10 @@

Modified 23 November 2006 by David A. Mellis
*/
//************************************************************************
//* Sep 28, 2010 <MLS> V0020 was released, migrated changes into 0020
//* Oct 5, 2010 <MLS> V0020 was released, migrated changes into 0021
//************************************************************************

#include <stdlib.h>
#include <stdio.h>
Expand Down Expand Up @@ -218,3 +222,28 @@ void Print::printFloat(double number, uint8_t digits)
remainder -= toPrint;
}
}


//************************************************************************
void Print::print_P(prog_char *flashMemStr)
{
char theChar;
int ii;

ii = 0;
#if (FLASHEND > 0x10000)
while (theChar = pgm_read_byte_far(flashMemStr + ii++))
#else
while (theChar = pgm_read_byte_near(flashMemStr + ii++))
#endif
{
print(theChar);
}
}

//************************************************************************
void Print::println_P(prog_char *flashMemStr)
{
print_P(flashMemStr);
println();
}
Loading