From 7aed6f3dec79dc0346a8875a4eef40f2292917d0 Mon Sep 17 00:00:00 2001 From: Mark Sproul Date: Thu, 30 Sep 2010 22:11:46 -0400 Subject: [PATCH 1/6] Using register #ifdefs instead of cpu #ifdefs --- .../arduino/cores/arduino/HardwareSerial.cpp | 197 ++++++++++++++---- .../arduino/cores/arduino/HardwareSerial.h | 22 +- 2 files changed, 170 insertions(+), 49 deletions(-) mode change 100755 => 100644 hardware/arduino/cores/arduino/HardwareSerial.cpp mode change 100755 => 100644 hardware/arduino/cores/arduino/HardwareSerial.h diff --git a/hardware/arduino/cores/arduino/HardwareSerial.cpp b/hardware/arduino/cores/arduino/HardwareSerial.cpp old mode 100755 new mode 100644 index e7ac21f7cf2..28449f69bdf --- a/hardware/arduino/cores/arduino/HardwareSerial.cpp +++ b/hardware/arduino/cores/arduino/HardwareSerial.cpp @@ -18,6 +18,17 @@ Modified 23 November 2006 by David A. Mellis */ +//******************************************************************************************* +//* Mar 14, 2010 Mark Sproul fixed bug in __AVR_ATmega644__ interrupt vector +//* Mar 25, 2010 Fixed bug in __AVR_ATmega644P__ interrupt vector +//* Apr 2, 2010 Changed RX_BUFFER_SIZE to 32 for smaller ram processors +//* Jul 30, 2010 Chainging #ifdefs to register and signals instead of CPU type +//* Aug 3, 2010 Tested on 644P 645 1280, 2560 328 and others +//* Aug 16, 2010 Added support for Atmega32 +//* Aug 31, 2010 The ATmega32U4 has uart1 but NOT uart0 +//* Sep 5, 2010 V0019 was released, migrated changes into 0019 +//* Sep 28, 2010 V0020 was released, migrated changes into 0020 +//******************************************************************************************* #include #include @@ -26,28 +37,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; @@ -62,52 +91,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) +//******************************************************************************************* +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) +//******************************************************************************************* +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, @@ -129,6 +218,7 @@ HardwareSerial::HardwareSerial(ring_buffer *rx_buffer, // Public Methods ////////////////////////////////////////////////////////////// +//******************************************************************************************* void HardwareSerial::begin(long baud) { uint16_t baud_setting; @@ -166,6 +256,7 @@ void HardwareSerial::begin(long baud) sbi(*_ucsrb, _rxcie); } +//******************************************************************************************* void HardwareSerial::end() { cbi(*_ucsrb, _rxen); @@ -173,11 +264,13 @@ void HardwareSerial::end() 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) { @@ -187,6 +280,7 @@ int HardwareSerial::peek(void) } } +//******************************************************************************************* int HardwareSerial::read(void) { // if the head isn't ahead of the tail, we don't have any characters @@ -199,6 +293,7 @@ int HardwareSerial::read(void) } } +//******************************************************************************************* void HardwareSerial::flush() { // don't reverse this or there may be problems if the RX interrupt @@ -213,6 +308,7 @@ void HardwareSerial::flush() _rx_buffer->head = _rx_buffer->tail; } +//******************************************************************************************* void HardwareSerial::write(uint8_t c) { while (!((*_ucsra) & (1 << _udre))) @@ -223,14 +319,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) diff --git a/hardware/arduino/cores/arduino/HardwareSerial.h b/hardware/arduino/cores/arduino/HardwareSerial.h old mode 100755 new mode 100644 index 29898b9535a..dcb979f08d0 --- a/hardware/arduino/cores/arduino/HardwareSerial.h +++ b/hardware/arduino/cores/arduino/HardwareSerial.h @@ -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 V0020 was released, migrated changes into 0020 +//******************************************************************************************* #ifndef HardwareSerial_h #define HardwareSerial_h @@ -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 From 07787001bf9298edc18088ef9273f52ec59fe096 Mon Sep 17 00:00:00 2001 From: Mark Sproul Date: Fri, 1 Oct 2010 09:27:54 -0400 Subject: [PATCH 2/6] Changed from cpu #ifdefs to register #ifdefs --- hardware/arduino/cores/arduino/wiring_analog.c | 10 ++++++++++ 1 file changed, 10 insertions(+) mode change 100755 => 100644 hardware/arduino/cores/arduino/wiring_analog.c diff --git a/hardware/arduino/cores/arduino/wiring_analog.c b/hardware/arduino/cores/arduino/wiring_analog.c old mode 100755 new mode 100644 index da0cf0781ad..d5164f8b3ee --- a/hardware/arduino/cores/arduino/wiring_analog.c +++ b/hardware/arduino/cores/arduino/wiring_analog.c @@ -21,12 +21,22 @@ $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $ */ +//******************************************************************************************* +//* Jul 27, 2010 = Mark Sproul msproul-at-skychariot.com +//* Jul 27, 2010 Rewrite of analogWrite to better support various cpus +//* Jul 27, 2010 Refactoring analogWrite() to test for register, not cpu, definitions. +//* Jul 28, 2010 submited enhancment request #307 +//* Aug 3, 2010 improved the #ifdefs, now compiles for atmega645 +//* Sep 5, 2010 V0019 was released, migrated changes into 0019 +//* Sep 28, 2010 V0020 was released, migrated changes into 0020 +//******************************************************************************************* #include "wiring_private.h" #include "pins_arduino.h" uint8_t analog_reference = DEFAULT; +//********************************************************************* void analogReference(uint8_t mode) { // can't actually set the register here because the default setting From 202e0741f33e81641cc21750226a6105d4f70e9c Mon Sep 17 00:00:00 2001 From: Mark Sproul Date: Fri, 1 Oct 2010 09:30:46 -0400 Subject: [PATCH 3/6] Changed from cpu #ifdefs to register #ifdefs --- hardware/arduino/cores/arduino/wiring_analog.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/hardware/arduino/cores/arduino/wiring_analog.c b/hardware/arduino/cores/arduino/wiring_analog.c index d5164f8b3ee..02701998640 100644 --- a/hardware/arduino/cores/arduino/wiring_analog.c +++ b/hardware/arduino/cores/arduino/wiring_analog.c @@ -45,28 +45,34 @@ void analogReference(uint8_t mode) analog_reference = mode; } +//********************************************************************* int analogRead(uint8_t pin) { uint8_t low, high; #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) if (pin >= 54) pin -= 54; // allow for channel or pin numbers +#else + if (pin >= 14) pin -= 14; // allow for channel or pin numbers +#endif +#if defined(ADCSRB) && defined(MUX5) // the MUX5 bit of ADCSRB selects whether we're reading from channels // 0 to 7 (MUX5 low) or 8 to 15 (MUX5 high). ADCSRB = (ADCSRB & ~(1 << MUX5)) | (((pin >> 3) & 0x01) << MUX5); -#else - if (pin >= 14) pin -= 14; // allow for channel or pin numbers #endif // set the analog reference (high two bits of ADMUX) and select the // channel (low 4 bits). this also sets ADLAR (left-adjust result) // to 0 (the default). +#if defined(ADMUX) ADMUX = (analog_reference << 6) | (pin & 0x07); +#endif // without a delay, we seem to read from the wrong channel //delay(1); +#if defined(ADCSRA) && defined(ADCL) // start the conversion sbi(ADCSRA, ADSC); From c69279331f3b90d34945cc365b399881f194ed2c Mon Sep 17 00:00:00 2001 From: Mark Sproul Date: Fri, 1 Oct 2010 10:25:06 -0400 Subject: [PATCH 4/6] changed from cpu #ifdefs to register #ifdefs --- .../arduino/cores/arduino/wiring_analog.c | 263 +++++++++++------- 1 file changed, 169 insertions(+), 94 deletions(-) diff --git a/hardware/arduino/cores/arduino/wiring_analog.c b/hardware/arduino/cores/arduino/wiring_analog.c index 02701998640..2703a8a8e78 100644 --- a/hardware/arduino/cores/arduino/wiring_analog.c +++ b/hardware/arduino/cores/arduino/wiring_analog.c @@ -83,17 +83,24 @@ int analogRead(uint8_t pin) // and ADCH until ADCH is read. reading ADCL second would // cause the results of each conversion to be discarded, // as ADCL and ADCH would be locked when it completed. - low = ADCL; - high = ADCH; + low = ADCL; + high = ADCH; +#else + //* we dont have an ADC, return 0 + low = 0; + high = 0; +#endif // combine the two bytes return (high << 8) | low; } +//********************************************************************* // Right now, PWM output only works on the pins with // hardware support. These are defined in the appropriate // pins_*.c file. For the rest of the pins, we default // to digital output. +//********************************************************************* void analogWrite(uint8_t pin, int val) { // We need to make sure the PWM output is enabled for those pins @@ -102,98 +109,166 @@ void analogWrite(uint8_t pin, int val) // for consistenty with Wiring, which doesn't require a pinMode // call for the analog output pins. pinMode(pin, OUTPUT); - - if (digitalPinToTimer(pin) == TIMER1A) { - // connect pwm to pin on timer 1, channel A - sbi(TCCR1A, COM1A1); - // set pwm duty - OCR1A = val; - } else if (digitalPinToTimer(pin) == TIMER1B) { - // connect pwm to pin on timer 1, channel B - sbi(TCCR1A, COM1B1); - // set pwm duty - OCR1B = val; -#if defined(__AVR_ATmega8__) - } else if (digitalPinToTimer(pin) == TIMER2) { - // connect pwm to pin on timer 2, channel B - sbi(TCCR2, COM21); - // set pwm duty - OCR2 = val; -#else - } else if (digitalPinToTimer(pin) == TIMER0A) { - if (val == 0) { - digitalWrite(pin, LOW); - } else { - // connect pwm to pin on timer 0, channel A - sbi(TCCR0A, COM0A1); - // set pwm duty - OCR0A = val; - } - } else if (digitalPinToTimer(pin) == TIMER0B) { - if (val == 0) { - digitalWrite(pin, LOW); - } else { - // connect pwm to pin on timer 0, channel B - sbi(TCCR0A, COM0B1); - // set pwm duty - OCR0B = val; - } - } else if (digitalPinToTimer(pin) == TIMER2A) { - // connect pwm to pin on timer 2, channel A - sbi(TCCR2A, COM2A1); - // set pwm duty - OCR2A = val; - } else if (digitalPinToTimer(pin) == TIMER2B) { - // connect pwm to pin on timer 2, channel B - sbi(TCCR2A, COM2B1); - // set pwm duty - OCR2B = val; -#endif -#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) - // XXX: need to handle other timers here - } else if (digitalPinToTimer(pin) == TIMER3A) { - // connect pwm to pin on timer 3, channel A - sbi(TCCR3A, COM3A1); - // set pwm duty - OCR3A = val; - } else if (digitalPinToTimer(pin) == TIMER3B) { - // connect pwm to pin on timer 3, channel B - sbi(TCCR3A, COM3B1); - // set pwm duty - OCR3B = val; - } else if (digitalPinToTimer(pin) == TIMER3C) { - // connect pwm to pin on timer 3, channel C - sbi(TCCR3A, COM3C1); - // set pwm duty - OCR3C = val; - } else if (digitalPinToTimer(pin) == TIMER4A) { - // connect pwm to pin on timer 4, channel A - sbi(TCCR4A, COM4A1); - // set pwm duty - OCR4A = val; - } else if (digitalPinToTimer(pin) == TIMER4B) { - // connect pwm to pin on timer 4, channel B - sbi(TCCR4A, COM4B1); - // set pwm duty - OCR4B = val; - } else if (digitalPinToTimer(pin) == TIMER4C) { - // connect pwm to pin on timer 4, channel C - sbi(TCCR4A, COM4C1); - // set pwm duty - OCR4C = val; - } else if (digitalPinToTimer(pin) == TIMER5A) { - // connect pwm to pin on timer 5, channel A - sbi(TCCR5A, COM5A1); - // set pwm duty - OCR5A = val; - } else if (digitalPinToTimer(pin) == TIMER5B) { - // connect pwm to pin on timer 5, channel B - sbi(TCCR5A, COM5B1); - // set pwm duty - OCR5B = val; -#endif - } else if (val < 128) + if (val == 0) + { digitalWrite(pin, LOW); - else + } + else if (val == 255) + { digitalWrite(pin, HIGH); + } + else + { + switch(digitalPinToTimer(pin)) + { + #if defined(TCCR0) && defined(COM00) && !defined(__AVR_ATmega8__) + //* I need to fix this for atmega8 + case TIMER0A: + // connect pwm to pin on timer 0 + sbi(TCCR0, COM00); + OCR0 = val; // set pwm duty + break; + #endif + + #if defined(TCCR0A) && defined(COM0A1) + case TIMER0A: + // connect pwm to pin on timer 0, channel A + sbi(TCCR0A, COM0A1); + OCR0A = val; // set pwm duty + break; + #endif + + #if defined(TCCR0A) && defined(COM0B1) + case TIMER0B: + // connect pwm to pin on timer 0, channel B + sbi(TCCR0A, COM0B1); + OCR0B = val; // set pwm duty + break; + #endif + + #if defined(TCCR1A) && defined(COM1A1) + case TIMER1A: + // connect pwm to pin on timer 1, channel A + sbi(TCCR1A, COM1A1); + OCR1A = val; // set pwm duty + break; + #endif + + #if defined(TCCR1A) && defined(COM1B1) + case TIMER1B: + // connect pwm to pin on timer 1, channel B + sbi(TCCR1A, COM1B1); + OCR1B = val; // set pwm duty + break; + #endif + + #if defined(TCCR2) && defined(COM21) + case TIMER2: + // connect pwm to pin on timer 2, channel B + sbi(TCCR2, COM21); + OCR2 = val; // set pwm duty + break; + #endif + + #if defined(TCCR2A) && defined(COM2A1) + case TIMER2A: + // connect pwm to pin on timer 2, channel A + sbi(TCCR2A, COM2A1); + OCR2A = val; // set pwm duty + break; + #endif + + #if defined(TCCR2A) && defined(COM2B1) + case TIMER2B: + // connect pwm to pin on timer 2, channel B + sbi(TCCR2A, COM2B1); + OCR2B = val; // set pwm duty + break; + #endif + + #if defined(TCCR3A) && defined(COM3A1) + case TIMER3A: + // connect pwm to pin on timer 3, channel A + sbi(TCCR3A, COM3A1); + OCR3A = val; // set pwm duty + break; + #endif + + #if defined(TCCR3A) && defined(COM3B1) + case TIMER3B: + // connect pwm to pin on timer 3, channel B + sbi(TCCR3A, COM3B1); + OCR3B = val; // set pwm duty + break; + #endif + + #if defined(TCCR3A) && defined(COM3C1) + case TIMER3C: + // connect pwm to pin on timer 3, channel C + sbi(TCCR3A, COM3C1); + OCR3C = val; // set pwm duty + break; + #endif + + #if defined(TCCR4A) && defined(COM4A1) + case TIMER4A: + // connect pwm to pin on timer 4, channel A + sbi(TCCR4A, COM4A1); + OCR4A = val; // set pwm duty + break; + #endif + + #if defined(TCCR4A) && defined(COM4B1) + case TIMER4B: + // connect pwm to pin on timer 4, channel B + sbi(TCCR4A, COM4B1); + OCR4B = val; // set pwm duty + break; + #endif + + #if defined(TCCR4A) && defined(COM4C1) + case TIMER4C: + // connect pwm to pin on timer 4, channel C + sbi(TCCR4A, COM4C1); + OCR4C = val; // set pwm duty + break; + #endif + + #if defined(TCCR5A) && defined(COM5A1) + case TIMER5A: + // connect pwm to pin on timer 5, channel A + sbi(TCCR5A, COM5A1); + OCR5A = val; // set pwm duty + break; + #endif + + #if defined(TCCR5A) && defined(COM5B1) + case TIMER5B: + // connect pwm to pin on timer 5, channel B + sbi(TCCR5A, COM5B1); + OCR5B = val; // set pwm duty + break; + #endif + + //* Jul 27, 2010 Added this, Its missing from the main core files + #if defined(TCCR5A) && defined(COM5C1) + case TIMER5C: + // connect pwm to pin on timer 5, channel C + sbi(TCCR5A, COM5C1); + OCR5C = val; // set pwm duty + break; + #endif + + case NOT_ON_TIMER: + default: + if (val < 128) + { + digitalWrite(pin, LOW); + } + else + { + digitalWrite(pin, HIGH); + } + } + } } From 803593da65a231076c050daa4f1e8b2a627dd0ba Mon Sep 17 00:00:00 2001 From: Mark Sproul Date: Wed, 6 Oct 2010 14:14:37 -0400 Subject: [PATCH 5/6] Changes to use register #ifdefs instead of cpu #ifdefs --- .../arduino/cores/arduino/HardwareSerial.cpp | 5 +- hardware/arduino/cores/arduino/Print.cpp | 29 + hardware/arduino/cores/arduino/Print.h | 14 + hardware/arduino/cores/arduino/Tone.cpp | 704 ++++++++++-------- hardware/arduino/cores/arduino/WInterrupts.c | 278 ++++--- hardware/arduino/cores/arduino/wiring.c | 118 ++- hardware/arduino/cores/arduino/wiring.h | 23 +- .../arduino/cores/arduino/wiring_digital.c | 125 +++- 8 files changed, 846 insertions(+), 450 deletions(-) diff --git a/hardware/arduino/cores/arduino/HardwareSerial.cpp b/hardware/arduino/cores/arduino/HardwareSerial.cpp index 28449f69bdf..db6f6ea0968 100644 --- a/hardware/arduino/cores/arduino/HardwareSerial.cpp +++ b/hardware/arduino/cores/arduino/HardwareSerial.cpp @@ -28,6 +28,7 @@ //* Aug 31, 2010 The ATmega32U4 has uart1 but NOT uart0 //* Sep 5, 2010 V0019 was released, migrated changes into 0019 //* Sep 28, 2010 V0020 was released, migrated changes into 0020 +//* Oct 1, 2010 Added more constraints to handle atmega128rfa1 //******************************************************************************************* #include @@ -170,7 +171,7 @@ SIGNAL(USART1_RX_vect) //#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) -#if defined(USART2_RX_vect) +#if defined(USART2_RX_vect) && defined(UDR2) //******************************************************************************************* SIGNAL(USART2_RX_vect) { @@ -181,7 +182,7 @@ SIGNAL(USART2_RX_vect) #error SIG_USART2_RECV #endif -#if defined(USART3_RX_vect) +#if defined(USART3_RX_vect) && defined(UDR3) //******************************************************************************************* SIGNAL(USART3_RX_vect) { diff --git a/hardware/arduino/cores/arduino/Print.cpp b/hardware/arduino/cores/arduino/Print.cpp index 4ee556dd82d..84e76aa0fb1 100755 --- a/hardware/arduino/cores/arduino/Print.cpp +++ b/hardware/arduino/cores/arduino/Print.cpp @@ -18,6 +18,10 @@ Modified 23 November 2006 by David A. Mellis */ +//************************************************************************ +//* Sep 28, 2010 V0020 was released, migrated changes into 0020 +//* Oct 5, 2010 V0020 was released, migrated changes into 0021 +//************************************************************************ #include #include @@ -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(); +} diff --git a/hardware/arduino/cores/arduino/Print.h b/hardware/arduino/cores/arduino/Print.h index b092ae51d13..6443a7ac7d8 100755 --- a/hardware/arduino/cores/arduino/Print.h +++ b/hardware/arduino/cores/arduino/Print.h @@ -16,6 +16,10 @@ 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 V0020 was released, migrated changes into 0020 +//* Oct 5, 2010 V0020 was released, migrated changes into 0021 +//************************************************************************ #ifndef Print_h #define Print_h @@ -23,8 +27,14 @@ #include #include // for size_t +#include + + #include "WString.h" +#undef BIN + + #define DEC 10 #define HEX 16 #define OCT 8 @@ -61,6 +71,10 @@ class Print void println(unsigned long, int = DEC); void println(double, int = 2); void println(void); + + + void print_P(prog_char *flashMemStr); + void println_P(prog_char *flashMemStr); }; #endif diff --git a/hardware/arduino/cores/arduino/Tone.cpp b/hardware/arduino/cores/arduino/Tone.cpp index e221ecfa588..cb7bc490e3c 100755 --- a/hardware/arduino/cores/arduino/Tone.cpp +++ b/hardware/arduino/cores/arduino/Tone.cpp @@ -30,22 +30,37 @@ Version Modified By Date Comments 0006 D Mellis 09/12/29 Replaced objects with functions *************************************************/ +//************************************************************************ +//* Aug 29, 2010 = Mark Sproul, msproul@skychariot.com +//* Aug 29, 2010 Changed #ifdefs from cpu to register +//* Aug 29, 2010 Added debug #define to enable debugging with various boards +//* Sep 5, 2010 V0019 was released, migrated changes into 0019 +//* Sep 28, 2010 V0020 was released, migrated changes into 0020 +//* Oct 5, 2010 V0020 was released, migrated changes into 0021 +//************************************************************************ + +//#define _DEBUG_TONE_ + +#ifdef _DEBUG_TONE_ + #include "WProgram.h" + #include "HardwareSerial.h" +#endif #include #include #include #include -#if defined(__AVR_ATmega8__) -#define TCCR2A TCCR2 -#define TCCR2B TCCR2 -#define COM2A1 COM21 -#define COM2A0 COM20 -#define OCR2A OCR2 -#define TIMSK2 TIMSK -#define OCIE2A OCIE2 -#define TIMER2_COMPA_vect TIMER2_COMP_vect -#define TIMSK1 TIMSK +#if defined(__AVR_ATmega8__) || defined(__AVR_ATmega128__) + #define TCCR2A TCCR2 + #define TCCR2B TCCR2 + #define COM2A1 COM21 + #define COM2A0 COM20 + #define OCR2A OCR2 + #define TIMSK2 TIMSK + #define OCIE2A OCIE2 + #define TIMER2_COMPA_vect TIMER2_COMP_vect + #define TIMSK1 TIMSK #endif // timerx_toggle_count: @@ -54,9 +69,9 @@ Version Modified By Date Comments // < 0 - infinitely (until stop() method called, or new play() called) #if !defined(__AVR_ATmega8__) -volatile long timer0_toggle_count; -volatile uint8_t *timer0_pin_port; -volatile uint8_t timer0_pin_mask; + volatile long timer0_toggle_count; + volatile uint8_t *timer0_pin_port; + volatile uint8_t timer0_pin_mask; #endif volatile long timer1_toggle_count; @@ -66,325 +81,423 @@ volatile long timer2_toggle_count; volatile uint8_t *timer2_pin_port; volatile uint8_t timer2_pin_mask; -#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) -volatile long timer3_toggle_count; -volatile uint8_t *timer3_pin_port; -volatile uint8_t timer3_pin_mask; -volatile long timer4_toggle_count; -volatile uint8_t *timer4_pin_port; -volatile uint8_t timer4_pin_mask; -volatile long timer5_toggle_count; -volatile uint8_t *timer5_pin_port; -volatile uint8_t timer5_pin_mask; +//#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) +#if defined(TIMSK3) + volatile long timer3_toggle_count; + volatile uint8_t *timer3_pin_port; + volatile uint8_t timer3_pin_mask; +#endif + +#if defined(TIMSK4) + volatile long timer4_toggle_count; + volatile uint8_t *timer4_pin_port; + volatile uint8_t timer4_pin_mask; +#endif + +#if defined(TIMSK5) + volatile long timer5_toggle_count; + volatile uint8_t *timer5_pin_port; + volatile uint8_t timer5_pin_mask; #endif +//* Aug 2010 This does not make sense, the 3 options are the same #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) -#define AVAILABLE_TONE_PINS 1 + #define AVAILABLE_TONE_PINS 1 -const uint8_t PROGMEM tone_pin_to_timer_PGM[] = { 2 /*, 3, 4, 5, 1, 0 */ }; -static uint8_t tone_pins[AVAILABLE_TONE_PINS] = { 255 /*, 255, 255, 255, 255, 255 */ }; + const uint8_t PROGMEM tone_pin_to_timer_PGM[] = { 2 /*, 3, 4, 5, 1, 0 */ }; + static uint8_t tone_pins[AVAILABLE_TONE_PINS] = { 255 /*, 255, 255, 255, 255, 255 */ }; #elif defined(__AVR_ATmega8__) -#define AVAILABLE_TONE_PINS 1 + #define AVAILABLE_TONE_PINS 1 -const uint8_t PROGMEM tone_pin_to_timer_PGM[] = { 2 /*, 1 */ }; -static uint8_t tone_pins[AVAILABLE_TONE_PINS] = { 255 /*, 255 */ }; + const uint8_t PROGMEM tone_pin_to_timer_PGM[] = { 2 /*, 1 */ }; + static uint8_t tone_pins[AVAILABLE_TONE_PINS] = { 255 /*, 255 */ }; #else -#define AVAILABLE_TONE_PINS 1 + #define AVAILABLE_TONE_PINS 1 -// Leave timer 0 to last. -const uint8_t PROGMEM tone_pin_to_timer_PGM[] = { 2 /*, 1, 0 */ }; -static uint8_t tone_pins[AVAILABLE_TONE_PINS] = { 255 /*, 255, 255 */ }; + // Leave timer 0 to last. + const uint8_t PROGMEM tone_pin_to_timer_PGM[] = { 2 /*, 1, 0 */ }; + static uint8_t tone_pins[AVAILABLE_TONE_PINS] = { 255 /*, 255, 255 */ }; #endif +//************************************************************************ static int8_t toneBegin(uint8_t _pin) { - int8_t _timer = -1; - - // if we're already using the pin, the timer should be configured. - for (int i = 0; i < AVAILABLE_TONE_PINS; i++) { - if (tone_pins[i] == _pin) { - return pgm_read_byte(tone_pin_to_timer_PGM + i); - } - } - - // search for an unused timer. - for (int i = 0; i < AVAILABLE_TONE_PINS; i++) { - if (tone_pins[i] == 255) { - tone_pins[i] = _pin; - _timer = pgm_read_byte(tone_pin_to_timer_PGM + i); - break; - } - } - - if (_timer != -1) - { - // Set timer specific stuff - // All timers in CTC mode - // 8 bit timers will require changing prescalar values, - // whereas 16 bit timers are set to either ck/1 or ck/64 prescalar - switch (_timer) - { -#if !defined(__AVR_ATmega8__) - case 0: - // 8 bit timer - TCCR0A = 0; - TCCR0B = 0; - bitWrite(TCCR0A, WGM01, 1); - bitWrite(TCCR0B, CS00, 1); - timer0_pin_port = portOutputRegister(digitalPinToPort(_pin)); - timer0_pin_mask = digitalPinToBitMask(_pin); - break; -#endif - - case 1: - // 16 bit timer - TCCR1A = 0; - TCCR1B = 0; - bitWrite(TCCR1B, WGM12, 1); - bitWrite(TCCR1B, CS10, 1); - timer1_pin_port = portOutputRegister(digitalPinToPort(_pin)); - timer1_pin_mask = digitalPinToBitMask(_pin); - break; - case 2: - // 8 bit timer - TCCR2A = 0; - TCCR2B = 0; - bitWrite(TCCR2A, WGM21, 1); - bitWrite(TCCR2B, CS20, 1); - timer2_pin_port = portOutputRegister(digitalPinToPort(_pin)); - timer2_pin_mask = digitalPinToBitMask(_pin); - break; - -#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) - case 3: - // 16 bit timer - TCCR3A = 0; - TCCR3B = 0; - bitWrite(TCCR3B, WGM32, 1); - bitWrite(TCCR3B, CS30, 1); - timer3_pin_port = portOutputRegister(digitalPinToPort(_pin)); - timer3_pin_mask = digitalPinToBitMask(_pin); - break; - case 4: - // 16 bit timer - TCCR4A = 0; - TCCR4B = 0; - bitWrite(TCCR4B, WGM42, 1); - bitWrite(TCCR4B, CS40, 1); - timer4_pin_port = portOutputRegister(digitalPinToPort(_pin)); - timer4_pin_mask = digitalPinToBitMask(_pin); - break; - case 5: - // 16 bit timer - TCCR5A = 0; - TCCR5B = 0; - bitWrite(TCCR5B, WGM52, 1); - bitWrite(TCCR5B, CS50, 1); - timer5_pin_port = portOutputRegister(digitalPinToPort(_pin)); - timer5_pin_mask = digitalPinToBitMask(_pin); - break; -#endif - } - } - - return _timer; + int8_t _timer = -1; + + // if we're already using the pin, the timer should be configured. + for (int i = 0; i < AVAILABLE_TONE_PINS; i++) + { + if (tone_pins[i] == _pin) + { + return pgm_read_byte(tone_pin_to_timer_PGM + i); + } + } + + // search for an unused timer. + for (int i = 0; i < AVAILABLE_TONE_PINS; i++) + { + if (tone_pins[i] == 255) + { + tone_pins[i] = _pin; + _timer = pgm_read_byte(tone_pin_to_timer_PGM + i); + break; + } + } + + if (_timer != -1) + { + // Set timer specific stuff + // All timers in CTC mode + // 8 bit timers will require changing prescalar values, + // whereas 16 bit timers are set to either ck/1 or ck/64 prescalar + switch (_timer) + { + //#if !defined(__AVR_ATmega8__) && !defined(__AVR_ATmega128__) + #if defined(TCCR0A) && defined(TCCR0B) + case 0: + // 8 bit timer + TCCR0A = 0; + TCCR0B = 0; + bitWrite(TCCR0A, WGM01, 1); + bitWrite(TCCR0B, CS00, 1); + timer0_pin_port = portOutputRegister(digitalPinToPort(_pin)); + timer0_pin_mask = digitalPinToBitMask(_pin); + break; + #endif + + #if defined(TCCR1A) && defined(TCCR1B) && defined(WGM12) + case 1: + // 16 bit timer + TCCR1A = 0; + TCCR1B = 0; + bitWrite(TCCR1B, WGM12, 1); + bitWrite(TCCR1B, CS10, 1); + timer1_pin_port = portOutputRegister(digitalPinToPort(_pin)); + timer1_pin_mask = digitalPinToBitMask(_pin); + break; + #endif + + + //#if !defined(__AVR_ATmega128__) + #if defined(TCCR2A) && defined(TCCR2B) + case 2: + // 8 bit timer + TCCR2A = 0; + TCCR2B = 0; + bitWrite(TCCR2A, WGM21, 1); + bitWrite(TCCR2B, CS20, 1); + timer2_pin_port = portOutputRegister(digitalPinToPort(_pin)); + timer2_pin_mask = digitalPinToBitMask(_pin); + break; + #endif + + //#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) + #if defined(TCCR3A) && defined(TCCR3B) && defined(TIMSK3) + case 3: + // 16 bit timer + TCCR3A = 0; + TCCR3B = 0; + bitWrite(TCCR3B, WGM32, 1); + bitWrite(TCCR3B, CS30, 1); + timer3_pin_port = portOutputRegister(digitalPinToPort(_pin)); + timer3_pin_mask = digitalPinToBitMask(_pin); + break; + #endif + + #if defined(TCCR4A) && defined(TCCR4B) && defined(TIMSK4) + case 4: + // 16 bit timer + TCCR4A = 0; + TCCR4B = 0; + #if defined(WGM42) + bitWrite(TCCR4B, WGM42, 1); + #elif defined(CS43) + #warning this may not be correct + //* atmega32u4 + bitWrite(TCCR4B, CS43, 1); + #endif + bitWrite(TCCR4B, CS40, 1); + timer4_pin_port = portOutputRegister(digitalPinToPort(_pin)); + timer4_pin_mask = digitalPinToBitMask(_pin); + break; + #endif + + #if defined(TCCR5A) && defined(TCCR5B) && defined(TIMSK5) + case 5: + // 16 bit timer + TCCR5A = 0; + TCCR5B = 0; + bitWrite(TCCR5B, WGM52, 1); + bitWrite(TCCR5B, CS50, 1); + timer5_pin_port = portOutputRegister(digitalPinToPort(_pin)); + timer5_pin_mask = digitalPinToBitMask(_pin); + break; + #endif + } + } + return _timer; } // frequency (in hertz) and duration (in milliseconds). +//************************************************************************ void tone(uint8_t _pin, unsigned int frequency, unsigned long duration) { - uint8_t prescalarbits = 0b001; - long toggle_count = 0; - uint32_t ocr = 0; - int8_t _timer; - - _timer = toneBegin(_pin); - - if (_timer >= 0) - { - // Set the pinMode as OUTPUT - pinMode(_pin, OUTPUT); - - // if we are using an 8 bit timer, scan through prescalars to find the best fit - if (_timer == 0 || _timer == 2) - { - ocr = F_CPU / frequency / 2 - 1; - prescalarbits = 0b001; // ck/1: same for both timers - if (ocr > 255) - { - ocr = F_CPU / frequency / 2 / 8 - 1; - prescalarbits = 0b010; // ck/8: same for both timers - - if (_timer == 2 && ocr > 255) - { - ocr = F_CPU / frequency / 2 / 32 - 1; - prescalarbits = 0b011; - } - - if (ocr > 255) - { - ocr = F_CPU / frequency / 2 / 64 - 1; - prescalarbits = _timer == 0 ? 0b011 : 0b100; - - if (_timer == 2 && ocr > 255) - { - ocr = F_CPU / frequency / 2 / 128 - 1; - prescalarbits = 0b101; - } - - if (ocr > 255) - { - ocr = F_CPU / frequency / 2 / 256 - 1; - prescalarbits = _timer == 0 ? 0b100 : 0b110; - if (ocr > 255) - { - // can't do any better than /1024 - ocr = F_CPU / frequency / 2 / 1024 - 1; - prescalarbits = _timer == 0 ? 0b101 : 0b111; - } - } - } - } - -#if !defined(__AVR_ATmega8__) - if (_timer == 0) - TCCR0B = prescalarbits; - else -#endif - TCCR2B = prescalarbits; - } - else - { - // two choices for the 16 bit timers: ck/1 or ck/64 - ocr = F_CPU / frequency / 2 - 1; - - prescalarbits = 0b001; - if (ocr > 0xffff) - { - ocr = F_CPU / frequency / 2 / 64 - 1; - prescalarbits = 0b011; - } - - if (_timer == 1) - TCCR1B = (TCCR1B & 0b11111000) | prescalarbits; -#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) - else if (_timer == 3) - TCCR3B = (TCCR3B & 0b11111000) | prescalarbits; - else if (_timer == 4) - TCCR4B = (TCCR4B & 0b11111000) | prescalarbits; - else if (_timer == 5) - TCCR5B = (TCCR5B & 0b11111000) | prescalarbits; -#endif - - } - - - // Calculate the toggle count - if (duration > 0) - { - toggle_count = 2 * frequency * duration / 1000; - } - else - { - toggle_count = -1; - } - - // Set the OCR for the given timer, - // set the toggle count, - // then turn on the interrupts - switch (_timer) - { - -#if !defined(__AVR_ATmega8__) - case 0: - OCR0A = ocr; - timer0_toggle_count = toggle_count; - bitWrite(TIMSK0, OCIE0A, 1); - break; -#endif - - case 1: - OCR1A = ocr; - timer1_toggle_count = toggle_count; - bitWrite(TIMSK1, OCIE1A, 1); - break; - case 2: - OCR2A = ocr; - timer2_toggle_count = toggle_count; - bitWrite(TIMSK2, OCIE2A, 1); - break; - -#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) - case 3: - OCR3A = ocr; - timer3_toggle_count = toggle_count; - bitWrite(TIMSK3, OCIE3A, 1); - break; - case 4: - OCR4A = ocr; - timer4_toggle_count = toggle_count; - bitWrite(TIMSK4, OCIE4A, 1); - break; - case 5: - OCR5A = ocr; - timer5_toggle_count = toggle_count; - bitWrite(TIMSK5, OCIE5A, 1); - break; -#endif - - } - } +uint8_t prescalarbits = 0b001; +long toggle_count = 0; +uint32_t ocr = 0; +int8_t _timer; + + _timer = toneBegin(_pin); + + if (_timer >= 0) + { + // Set the pinMode as OUTPUT + pinMode(_pin, OUTPUT); + + // if we are using an 8 bit timer, scan through prescalars to find the best fit + if (_timer == 0 || _timer == 2) + { + ocr = F_CPU / frequency / 2 - 1; + prescalarbits = 0b001; // ck/1: same for both timers + if (ocr > 255) + { + ocr = F_CPU / frequency / 2 / 8 - 1; + prescalarbits = 0b010; // ck/8: same for both timers + + if (_timer == 2 && ocr > 255) + { + ocr = F_CPU / frequency / 2 / 32 - 1; + prescalarbits = 0b011; + } + + if (ocr > 255) + { + ocr = F_CPU / frequency / 2 / 64 - 1; + prescalarbits = _timer == 0 ? 0b011 : 0b100; + + if (_timer == 2 && ocr > 255) + { + ocr = F_CPU / frequency / 2 / 128 - 1; + prescalarbits = 0b101; + } + + if (ocr > 255) + { + ocr = F_CPU / frequency / 2 / 256 - 1; + prescalarbits = _timer == 0 ? 0b100 : 0b110; + if (ocr > 255) + { + // can't do any better than /1024 + ocr = F_CPU / frequency / 2 / 1024 - 1; + prescalarbits = _timer == 0 ? 0b101 : 0b111; + } + } + } + } + + #if defined(TCCR0B) + if (_timer == 0) + { + TCCR0B = prescalarbits; + } + else + #endif + #if defined(TCCR2B) + { + TCCR2B = prescalarbits; + } + #else + { + //* dumy place holder to make the above ifdefs work + } + #endif + } + else + { + // two choices for the 16 bit timers: ck/1 or ck/64 + ocr = F_CPU / frequency / 2 - 1; + + prescalarbits = 0b001; + if (ocr > 0xffff) + { + ocr = F_CPU / frequency / 2 / 64 - 1; + prescalarbits = 0b011; + } + + if (_timer == 1) + { + #if defined(TCCR1B) + TCCR1B = (TCCR1B & 0b11111000) | prescalarbits; + #endif + } + //#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) + #if defined(TCCR3B) + else if (_timer == 3) + TCCR3B = (TCCR3B & 0b11111000) | prescalarbits; + #endif + #if defined(TCCR4B) + else if (_timer == 4) + TCCR4B = (TCCR4B & 0b11111000) | prescalarbits; + #endif + #if defined(TCCR5B) + else if (_timer == 5) + TCCR5B = (TCCR5B & 0b11111000) | prescalarbits; + #endif + + } + + + // Calculate the toggle count + if (duration > 0) + { + toggle_count = 2 * frequency * duration / 1000; + } + else + { + toggle_count = -1; + } + + // Set the OCR for the given timer, + // set the toggle count, + // then turn on the interrupts + switch (_timer) + { + + //#if !defined(__AVR_ATmega8__) + #if defined(OCR0A) && defined(TIMSK0) && defined(OCIE0A) + case 0: + OCR0A = ocr; + timer0_toggle_count = toggle_count; + bitWrite(TIMSK0, OCIE0A, 1); + break; + #endif + + case 1: + #if defined(OCR1A) && defined(TIMSK1) && defined(OCIE1A) + OCR1A = ocr; + timer1_toggle_count = toggle_count; + bitWrite(TIMSK1, OCIE1A, 1); + #elif defined(OCR1A) && defined(TIMSK) && defined(OCIE1A) + //* this combination is for at least the ATmega32 + OCR1A = ocr; + timer1_toggle_count = toggle_count; + bitWrite(TIMSK, OCIE1A, 1); + #endif + break; + + #if defined(OCR2A) && defined(TIMSK2) && defined(OCIE2A) + case 2: + OCR2A = ocr; + timer2_toggle_count = toggle_count; + bitWrite(TIMSK2, OCIE2A, 1); + break; + #endif + +// #if defined(__AVR_ATmega1280__) + #if defined(TIMSK3) + case 3: + OCR3A = ocr; + timer3_toggle_count = toggle_count; + bitWrite(TIMSK3, OCIE3A, 1); + break; + #endif + + #if defined(TIMSK4) + case 4: + OCR4A = ocr; + timer4_toggle_count = toggle_count; + bitWrite(TIMSK4, OCIE4A, 1); + break; + #endif + + #if defined(OCR5A) && defined(TIMSK5) && defined(OCIE5A) + case 5: + OCR5A = ocr; + timer5_toggle_count = toggle_count; + bitWrite(TIMSK5, OCIE5A, 1); + break; + #endif + + } + } } +//************************************************************************ // XXX: this function only works properly for timer 2 (the only one we use // currently). for the others, it should end the tone, but won't restore // proper PWM functionality for the timer. +//************************************************************************ void disableTimer(uint8_t _timer) { - switch (_timer) - { -#if !defined(__AVR_ATmega8__) - case 0: - TIMSK0 = 0; - break; -#endif - case 1: - bitWrite(TIMSK1, OCIE1A, 0); - break; - case 2: - bitWrite(TIMSK2, OCIE2A, 0); // disable interrupt - TCCR2A = (1 << WGM20); - TCCR2B = (TCCR2B & 0b11111000) | (1 << CS22); - OCR2A = 0; - break; -#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) - case 3: - TIMSK3 = 0; - break; - case 4: - TIMSK4 = 0; - break; - case 5: - TIMSK5 = 0; - break; -#endif - } + switch (_timer) + { +// #if !defined(__AVR_ATmega8__) + case 0: + #if defined(TIMSK0) + TIMSK0 = 0; + #elif defined(TIMSK) + TIMSK = 0; //* atmega32 + #endif + break; + + #if defined(TIMSK1) && defined(OCIE1A) + case 1: + bitWrite(TIMSK1, OCIE1A, 0); + break; + #endif + + case 2: + #if defined(TIMSK2) && defined(OCIE2A) + bitWrite(TIMSK2, OCIE2A, 0); // disable interrupt + #endif + #if defined(TCCR2A) && defined(WGM20) + TCCR2A = (1 << WGM20); + #endif + #if defined(TCCR2B) && defined(CS22) + TCCR2B = (TCCR2B & 0b11111000) | (1 << CS22); + #endif + #if defined(OCR2A) + OCR2A = 0; + #endif + break; + +// #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) + #if defined(TIMSK3) + case 3: + TIMSK3 = 0; + break; + #endif + + #if defined(TIMSK4) + case 4: + TIMSK4 = 0; + break; + + #endif + + #if defined(TIMSK5) + case 5: + TIMSK5 = 0; + break; + #endif + } } +//************************************************************************ void noTone(uint8_t _pin) { int8_t _timer = -1; @@ -422,6 +535,7 @@ ISR(TIMER0_COMPA_vect) #endif +//************************************************************************ ISR(TIMER1_COMPA_vect) { if (timer1_toggle_count != 0) @@ -441,7 +555,8 @@ ISR(TIMER1_COMPA_vect) #endif -ISR(TIMER2_COMPA_vect) +//************************************************************************ +ISR(TIMER2_COMPA_vect, ) { if (timer2_toggle_count != 0) @@ -464,6 +579,7 @@ ISR(TIMER2_COMPA_vect) //#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) #if 0 +//************************************************************************ ISR(TIMER3_COMPA_vect) { if (timer3_toggle_count != 0) @@ -481,6 +597,7 @@ ISR(TIMER3_COMPA_vect) } } +//************************************************************************ ISR(TIMER4_COMPA_vect) { if (timer4_toggle_count != 0) @@ -498,6 +615,7 @@ ISR(TIMER4_COMPA_vect) } } +//************************************************************************ ISR(TIMER5_COMPA_vect) { if (timer5_toggle_count != 0) diff --git a/hardware/arduino/cores/arduino/WInterrupts.c b/hardware/arduino/cores/arduino/WInterrupts.c index 9c5741148ca..d4b83be86e4 100755 --- a/hardware/arduino/cores/arduino/WInterrupts.c +++ b/hardware/arduino/cores/arduino/WInterrupts.c @@ -22,6 +22,13 @@ Modified 24 November 2006 by David A. Mellis */ +//************************************************************************ +//* Aug 1, 2010 = Mark Sproul msproul-at-skychariot.com +//* Aug 1, 2010 Working on converting cpu #ifdefs to register #ifdefs +//* Aug 2, 2010 Working for atemgeg645 +//* Aug 30, 2010 Working for attiny2313 +//* Sep 28, 2010 V0020 was released, migrated changes into 0020 +//************************************************************************ #include #include @@ -36,112 +43,176 @@ volatile static voidFuncPtr intFunc[EXTERNAL_NUM_INTERRUPTS]; // volatile static voidFuncPtr twiIntFunc; #if defined(__AVR_ATmega8__) -#define EICRA MCUCR -#define EIMSK GICR + //#define EICRA MCUCR + //#define EIMSK GICR #endif -void attachInterrupt(uint8_t interruptNum, void (*userFunc)(void), int mode) { - if(interruptNum < EXTERNAL_NUM_INTERRUPTS) { - intFunc[interruptNum] = userFunc; - - // Configure the interrupt mode (trigger on low input, any change, rising - // edge, or falling edge). The mode constants were chosen to correspond - // to the configuration bits in the hardware register, so we simply shift - // the mode into place. - - // Enable the interrupt. - - switch (interruptNum) { -#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) - case 2: - EICRA = (EICRA & ~((1 << ISC00) | (1 << ISC01))) | (mode << ISC00); - EIMSK |= (1 << INT0); - break; - case 3: - EICRA = (EICRA & ~((1 << ISC10) | (1 << ISC11))) | (mode << ISC10); - EIMSK |= (1 << INT1); - break; - case 4: - EICRA = (EICRA & ~((1 << ISC20) | (1 << ISC21))) | (mode << ISC20); - EIMSK |= (1 << INT2); - break; - case 5: - EICRA = (EICRA & ~((1 << ISC30) | (1 << ISC31))) | (mode << ISC30); - EIMSK |= (1 << INT3); - break; - case 0: - EICRB = (EICRB & ~((1 << ISC40) | (1 << ISC41))) | (mode << ISC40); - EIMSK |= (1 << INT4); - break; - case 1: - EICRB = (EICRB & ~((1 << ISC50) | (1 << ISC51))) | (mode << ISC50); - EIMSK |= (1 << INT5); - break; - case 6: - EICRB = (EICRB & ~((1 << ISC60) | (1 << ISC61))) | (mode << ISC60); - EIMSK |= (1 << INT6); - break; - case 7: - EICRB = (EICRB & ~((1 << ISC70) | (1 << ISC71))) | (mode << ISC70); - EIMSK |= (1 << INT7); - break; -#else - case 0: - EICRA = (EICRA & ~((1 << ISC00) | (1 << ISC01))) | (mode << ISC00); - EIMSK |= (1 << INT0); - break; - case 1: - EICRA = (EICRA & ~((1 << ISC10) | (1 << ISC11))) | (mode << ISC10); - EIMSK |= (1 << INT1); - break; -#endif - } - } +//************************************************************************ +void attachInterrupt(uint8_t interruptNum, void (*userFunc)(void), int mode) +{ + if(interruptNum < EXTERNAL_NUM_INTERRUPTS) + { + intFunc[interruptNum] = userFunc; + + // Configure the interrupt mode (trigger on low input, any change, rising + // edge, or falling edge). The mode constants were chosen to correspond + // to the configuration bits in the hardware register, so we simply shift + // the mode into place. + + // Enable the interrupt. + + switch (interruptNum) + { +// #if defined(__AVR_ATmega1280__) + #if defined(EICRA) && defined(EICRB) && defined(EIMSK) + case 2: + EICRA = (EICRA & ~((1 << ISC00) | (1 << ISC01))) | (mode << ISC00); + EIMSK |= (1 << INT0); + break; + + case 3: + EICRA = (EICRA & ~((1 << ISC10) | (1 << ISC11))) | (mode << ISC10); + EIMSK |= (1 << INT1); + break; + + case 4: + EICRA = (EICRA & ~((1 << ISC20) | (1 << ISC21))) | (mode << ISC20); + EIMSK |= (1 << INT2); + break; + + case 5: + EICRA = (EICRA & ~((1 << ISC30) | (1 << ISC31))) | (mode << ISC30); + EIMSK |= (1 << INT3); + break; + + case 0: + EICRB = (EICRB & ~((1 << ISC40) | (1 << ISC41))) | (mode << ISC40); + EIMSK |= (1 << INT4); + break; + + case 1: + EICRB = (EICRB & ~((1 << ISC50) | (1 << ISC51))) | (mode << ISC50); + EIMSK |= (1 << INT5); + break; + + case 6: + EICRB = (EICRB & ~((1 << ISC60) | (1 << ISC61))) | (mode << ISC60); + EIMSK |= (1 << INT6); + break; + + case 7: + EICRB = (EICRB & ~((1 << ISC70) | (1 << ISC71))) | (mode << ISC70); + EIMSK |= (1 << INT7); + break; + #else + case 0: + #if defined(EICRA) && defined(ISC00) && defined(EIMSK) + EICRA = (EICRA & ~((1 << ISC00) | (1 << ISC01))) | (mode << ISC00); + EIMSK |= (1 << INT0); + #elif defined(MCUCR) && defined(ISC00) && defined(GICR) + MCUCR = (MCUCR & ~((1 << ISC00) | (1 << ISC01))) | (mode << ISC00); + GICR |= (1 << INT0); + #elif defined(MCUCR) && defined(ISC00) && defined(GIMSK) + MCUCR = (MCUCR & ~((1 << ISC00) | (1 << ISC01))) | (mode << ISC00); + GIMSK |= (1 << INT0); + #else + #error attachInterrupt not finished for this CPU (case 0) + #endif + break; + + case 1: + #if defined(EICRA) && defined(ISC10) && defined(ISC11) && defined(EIMSK) + EICRA = (EICRA & ~((1 << ISC10) | (1 << ISC11))) | (mode << ISC10); + EIMSK |= (1 << INT1); + #elif defined(MCUCR) && defined(ISC10) && defined(ISC11) && defined(GICR) + MCUCR = (MCUCR & ~((1 << ISC10) | (1 << ISC11))) | (mode << ISC10); + GICR |= (1 << INT1); + #elif defined(MCUCR) && defined(ISC10) && defined(GIMSK) && defined(GIMSK) + MCUCR = (MCUCR & ~((1 << ISC10) | (1 << ISC11))) | (mode << ISC10); + GIMSK |= (1 << INT1); + #else + #warning attachInterrupt may need some more work for this cpu (case 1) + #endif + break; + #endif + } + } } -void detachInterrupt(uint8_t interruptNum) { - if(interruptNum < EXTERNAL_NUM_INTERRUPTS) { - // Disable the interrupt. (We can't assume that interruptNum is equal - // to the number of the EIMSK bit to clear, as this isn't true on the - // ATmega8. There, INT0 is 6 and INT1 is 7.) - switch (interruptNum) { -#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) - case 2: - EIMSK &= ~(1 << INT0); - break; - case 3: - EIMSK &= ~(1 << INT1); - break; - case 4: - EIMSK &= ~(1 << INT2); - break; - case 5: - EIMSK &= ~(1 << INT3); - break; - case 0: - EIMSK &= ~(1 << INT4); - break; - case 1: - EIMSK &= ~(1 << INT5); - break; - case 6: - EIMSK &= ~(1 << INT6); - break; - case 7: - EIMSK &= ~(1 << INT7); - break; -#else - case 0: - EIMSK &= ~(1 << INT0); - break; - case 1: - EIMSK &= ~(1 << INT1); - break; -#endif - } - - intFunc[interruptNum] = 0; - } +//************************************************************************ +void detachInterrupt(uint8_t interruptNum) +{ + if(interruptNum < EXTERNAL_NUM_INTERRUPTS) + { + // Disable the interrupt. (We can't assume that interruptNum is equal + // to the number of the EIMSK bit to clear, as this isn't true on the + // ATmega8. There, INT0 is 6 and INT1 is 7.) + switch (interruptNum) + { +// #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) + #if defined(EICRA) && defined(EICRB) && defined(EIMSK) + + case 2: + EIMSK &= ~(1 << INT0); + break; + + case 3: + EIMSK &= ~(1 << INT1); + break; + + case 4: + EIMSK &= ~(1 << INT2); + break; + + case 5: + EIMSK &= ~(1 << INT3); + break; + + case 0: + EIMSK &= ~(1 << INT4); + break; + + case 1: + EIMSK &= ~(1 << INT5); + break; + + case 6: + EIMSK &= ~(1 << INT6); + break; + + case 7: + EIMSK &= ~(1 << INT7); + break; + #else + case 0: + #if defined(EIMSK) && defined(INT0) + EIMSK &= ~(1 << INT0); + #elif defined(GICR) && defined(ISC00) + GICR &= ~(1 << INT0); //* atmega32 + #elif defined(GIMSK) && defined(INT0) + GIMSK &= ~(1 << INT0); + #else + #error detachInterrupt not finished for this cpu + #endif + break; + + + case 1: + #if defined(EIMSK) && defined(INT1) + EIMSK &= ~(1 << INT1); + #elif defined(GICR) && defined(INT1) + GICR &= ~(1 << INT1); //* atmega32 + #elif defined(GIMSK) && defined(INT1) + GIMSK &= ~(1 << INT1); + #else + #warning detachInterrupt may need some more work for this cpu (case 1) + #endif + break; + #endif + } + + intFunc[interruptNum] = 0; + } } /* @@ -150,7 +221,8 @@ void attachInterruptTwi(void (*userFunc)(void) ) { } */ -#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) +//#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) +#if defined(EICRA) && defined(EICRB) SIGNAL(INT0_vect) { if(intFunc[EXTERNAL_INT_2]) diff --git a/hardware/arduino/cores/arduino/wiring.c b/hardware/arduino/cores/arduino/wiring.c index eb2d44001d4..2fe5d0593d8 100755 --- a/hardware/arduino/cores/arduino/wiring.c +++ b/hardware/arduino/cores/arduino/wiring.c @@ -21,6 +21,14 @@ $Id$ */ +//******************************************************************************************* +//* Aug 13, 2010 = Mark Sproul msproul-at-skychariot.com +//* Aug 13, 2010 Changed cpu ifdefs to register ifdefs +//* Sep 5, 2010 V0019 was released, migrated changes into 0019 +//* Sep 23, 2010 Added test for TCNT0 to support attiny861 +//* Sep 28, 2010 V0020 was released, migrated changes into 0020 +//* Oct 5, 2010 V0020 was released, migrated changes into 0021 +//******************************************************************************************* #include "wiring_private.h" @@ -41,6 +49,7 @@ volatile unsigned long timer0_overflow_count = 0; volatile unsigned long timer0_millis = 0; static unsigned char timer0_fract = 0; +//************************************************************************ SIGNAL(TIMER0_OVF_vect) { // copy these to local variables so they can be stored in registers @@ -60,6 +69,7 @@ SIGNAL(TIMER0_OVF_vect) timer0_overflow_count++; } +//************************************************************************ unsigned long millis() { unsigned long m; @@ -74,14 +84,22 @@ unsigned long millis() return m; } +//************************************************************************ unsigned long micros() { unsigned long m; uint8_t oldSREG = SREG, t; cli(); m = timer0_overflow_count; +#if defined(TCNT0) t = TCNT0; - +#elif defined(TCNT0L) + t = TCNT0L; +#else + #error TIMER 0 not defined +#endif + + #ifdef TIFR0 if ((TIFR0 & _BV(TOV0)) && (t < 255)) m++; @@ -95,6 +113,7 @@ unsigned long micros() { return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond()); } +//************************************************************************ void delay(unsigned long ms) { uint16_t start = (uint16_t)micros(); @@ -107,6 +126,7 @@ void delay(unsigned long ms) } } +//************************************************************************ /* Delay for the given number of microseconds. Assumes a 8 or 16 MHz clock. */ void delayMicroseconds(unsigned int us) { @@ -157,6 +177,7 @@ void delayMicroseconds(unsigned int us) ); } +//************************************************************************ void init() { // this needs to be called before setup() or some functions won't @@ -166,62 +187,109 @@ void init() // on the ATmega168, timer 0 is also used for fast hardware pwm // (using phase-correct PWM would mean that timer 0 overflowed half as often // resulting in different millis() behavior on the ATmega8 and ATmega168) -#if !defined(__AVR_ATmega8__) + +//#if !defined(__AVR_ATmega8__) && !defined(__AVR_ATmega128__) +#if defined(TCCR0A) && defined(WGM01) sbi(TCCR0A, WGM01); sbi(TCCR0A, WGM00); #endif - // set timer 0 prescale factor to 64 -#if defined(__AVR_ATmega8__) + + +//* set timer 0 prescale factor to 64 +#if defined(__AVR_ATmega128__) +//* I dont like to have to CPU specific but its different values for the ATmega128 + sbi(TCCR0, CS02); +#elif defined(TCCR0) && defined(CS01) && defined(CS00) + //* this combination is for the standard atmega8 sbi(TCCR0, CS01); sbi(TCCR0, CS00); -#else +#elif defined(TCCR0B) && defined(CS01) && defined(CS00) + //* this combination is for the standard 168/328/1280/2560 sbi(TCCR0B, CS01); sbi(TCCR0B, CS00); +#elif defined(TCCR0A) && defined(CS01) && defined(CS00) + //* this combination is for the __AVR_ATmega645__ series + sbi(TCCR0A, CS01); + sbi(TCCR0A, CS00); +#else + #error Timer 0 prescale factor 64 not set correctly #endif + + // enable timer 0 overflow interrupt -#if defined(__AVR_ATmega8__) +//#if defined(__AVR_ATmega8__) || defined(__AVR_ATmega128__) +#if defined(TIMSK) && defined(TOIE0) sbi(TIMSK, TOIE0); -#else +#elif defined(TIMSK0) && defined(TOIE0) sbi(TIMSK0, TOIE0); +#else + #error Timer 0 overflow interrupt not set correctly #endif // timers 1 and 2 are used for phase-correct hardware pwm // this is better for motors as it ensures an even waveform // note, however, that fast pwm mode can achieve a frequency of up // 8 MHz (with a 16 MHz clock) at 50% duty cycle - - TCCR1B = 0; + + TCCR1B = 0; // set timer 1 prescale factor to 64 +#if defined(TCCR1B) && defined(CS11) && defined(CS10) sbi(TCCR1B, CS11); sbi(TCCR1B, CS10); +#elif defined(TCCR1) && defined(CS11) && defined(CS10) + sbi(TCCR1, CS11); + sbi(TCCR1, CS10); +#endif // put timer 1 in 8-bit phase correct pwm mode +#if defined(TCCR1A) && defined(WGM10) sbi(TCCR1A, WGM10); +#elif defined(TCCR1) +// #error, this needs to be finished + #warning, this needs to be finished +#endif // set timer 2 prescale factor to 64 -#if defined(__AVR_ATmega8__) +//#if defined(__AVR_ATmega8__) || defined(__AVR_ATmega128__) +#if defined(TCCR2) && defined(CS22) sbi(TCCR2, CS22); -#else +#elif defined(TCCR2B) && defined(CS22) sbi(TCCR2B, CS22); +#else + #warning Timer 2 not finished (may not be present on this CPU) #endif + // configure timer 2 for phase correct pwm (8-bit) -#if defined(__AVR_ATmega8__) +//#if defined(__AVR_ATmega8__) || defined(__AVR_ATmega128__) +#if defined(TCCR2) && defined(WGM20) sbi(TCCR2, WGM20); -#else +#elif defined(TCCR2A) && defined(WGM20) sbi(TCCR2A, WGM20); +#else + #warning Timer 2 not finished (may not be present on this CPU) #endif -#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) - // set timer 3, 4, 5 prescale factor to 64 - sbi(TCCR3B, CS31); sbi(TCCR3B, CS30); - sbi(TCCR4B, CS41); sbi(TCCR4B, CS40); - sbi(TCCR5B, CS51); sbi(TCCR5B, CS50); - // put timer 3, 4, 5 in 8-bit phase correct pwm mode - sbi(TCCR3A, WGM30); - sbi(TCCR4A, WGM40); - sbi(TCCR5A, WGM50); +//#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) + +#if defined(TCCR3B) && defined(CS31) && defined(WGM30) + sbi(TCCR3B, CS31); // set timer 3, 4, 5 prescale factor to 64 + sbi(TCCR3B, CS30); + sbi(TCCR3A, WGM30); // put timer 3, 4, 5 in 8-bit phase correct pwm mode +#endif + +#if defined(TCCR4B) && defined(CS41) && defined(WGM40) + sbi(TCCR4B, CS41); // set timer 3, 4, 5 prescale factor to 64 + sbi(TCCR4B, CS40); + sbi(TCCR4A, WGM40); // put timer 3, 4, 5 in 8-bit phase correct pwm mode #endif +#if defined(TCCR5B) && defined(CS51) && defined(WGM50) + sbi(TCCR5B, CS51); // set timer 3, 4, 5 prescale factor to 64 + sbi(TCCR5B, CS50); + sbi(TCCR5A, WGM50); // put timer 3, 4, 5 in 8-bit phase correct pwm mode +#endif + +#if defined(ADCSRA) // set a2d prescale factor to 128 // 16 MHz / 128 = 125 KHz, inside the desired 50-200 KHz range. // XXX: this will not work properly for other clock speeds, and @@ -232,13 +300,15 @@ void init() // enable a2d conversions sbi(ADCSRA, ADEN); +#endif // the bootloader connects pins 0 and 1 to the USART; disconnect them // here so they can be used as normal digital i/o; they will be // reconnected in Serial.begin() -#if defined(__AVR_ATmega8__) +//#if defined(__AVR_ATmega8__) +#if defined(UCSRB) UCSRB = 0; -#else +#elif defined(UCSR0B) UCSR0B = 0; #endif } \ No newline at end of file diff --git a/hardware/arduino/cores/arduino/wiring.h b/hardware/arduino/cores/arduino/wiring.h index 7245797e3af..90bc9d48214 100755 --- a/hardware/arduino/cores/arduino/wiring.h +++ b/hardware/arduino/cores/arduino/wiring.h @@ -21,6 +21,10 @@ $Id$ */ +//******************************************************************************************* +//* Sep 28, 2010 V0020 was released, migrated changes into 0020 +//* Oct 5, 2010 V0020 was released, migrated changes into 0021 +//******************************************************************************************* #ifndef Wiring_h #define Wiring_h @@ -39,6 +43,10 @@ extern "C"{ #define INPUT 0x0 #define OUTPUT 0x1 +#undef true +#undef false + + #define true 0x1 #define false 0x0 @@ -84,9 +92,18 @@ extern "C"{ #define interrupts() sei() #define noInterrupts() cli() -#define clockCyclesPerMicrosecond() ( F_CPU / 1000000L ) -#define clockCyclesToMicroseconds(a) ( (a) / clockCyclesPerMicrosecond() ) -#define microsecondsToClockCycles(a) ( (a) * clockCyclesPerMicrosecond() ) +#if (F_CPU == 16000000L) || (F_CPU == 8000000L) || (F_CPU == 20000000L) + #define clockCyclesPerMicrosecond() ( F_CPU / 1000000L ) + #define clockCyclesToMicroseconds(a) ( (a) / clockCyclesPerMicrosecond() ) + #define microsecondsToClockCycles(a) ( (a) * clockCyclesPerMicrosecond() ) +#else +//* Aug 4, 2010 = Mark Sproul +//* if the clock is not an even multiple of 1000000, then the above causes drift +//* for example, (F_CPU == 14745600L) + #define clockCyclesPerMicrosecond() ( F_CPU / 1000000L ) + #define clockCyclesToMicroseconds(a) ( (a * 1000L) / (F_CPU / 1000L) ) + #define microsecondsToClockCycles(a) (( (a) * (F_CPU / 1000) ) / 1000) +#endif #define lowByte(w) ((uint8_t) ((w) & 0xff)) #define highByte(w) ((uint8_t) ((w) >> 8)) diff --git a/hardware/arduino/cores/arduino/wiring_digital.c b/hardware/arduino/cores/arduino/wiring_digital.c index 1475f0c0478..ffed8d6be18 100755 --- a/hardware/arduino/cores/arduino/wiring_digital.c +++ b/hardware/arduino/cores/arduino/wiring_digital.c @@ -21,10 +21,21 @@ $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $ */ +//********************************************************************************* +//* Jul 30, 2010 = Mark Sproul msproul@skychariot.com +//* Jul 30, 2010 Working on #ifdefs to better support various cpus +//* Jul 30, 2010 Removed inline. Save 170 bytes on atmega1280 +//* Jul 30, 2010 changed to a switch statment; added 32 bytes but much easier to read and maintain. +//* Aug 3, 2010 Added more #ifdefs, now compiles for atmega645 +//* Aug 30, 2010 Added more #ifdefs, now compiles for atmega1284p +//* Sep 28, 2010 V0020 was released, migrated changes into 0020 +//* Oct 5, 2010 V0020 was released, migrated changes into 0021 +//********************************************************************************* #include "wiring_private.h" #include "pins_arduino.h" +//********************************************************************* void pinMode(uint8_t pin, uint8_t mode) { uint8_t bit = digitalPinToBitMask(pin); @@ -49,6 +60,8 @@ void pinMode(uint8_t pin, uint8_t mode) } } + +//********************************************************************************* // Forcing this inline keeps the callers from having to push their own stuff // on the stack. It is a good performance win and only takes 1 more byte per // user than calling. (It will take more bytes on the 168.) @@ -56,34 +69,95 @@ void pinMode(uint8_t pin, uint8_t mode) // But shouldn't this be moved into pinMode? Seems silly to check and do on // each digitalread or write. // -static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline)); -static inline void turnOffPWM(uint8_t timer) +//********************************************************************************* +//static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline)); +//static inline void turnOffPWM(uint8_t timer) +static void turnOffPWM(uint8_t timer) { - if (timer == TIMER1A) cbi(TCCR1A, COM1A1); - if (timer == TIMER1B) cbi(TCCR1A, COM1B1); - -#if defined(__AVR_ATmega8__) - if (timer == TIMER2) cbi(TCCR2, COM21); -#else - if (timer == TIMER0A) cbi(TCCR0A, COM0A1); - if (timer == TIMER0B) cbi(TCCR0A, COM0B1); - if (timer == TIMER2A) cbi(TCCR2A, COM2A1); - if (timer == TIMER2B) cbi(TCCR2A, COM2B1); -#endif - -#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) - if (timer == TIMER3A) cbi(TCCR3A, COM3A1); - if (timer == TIMER3B) cbi(TCCR3A, COM3B1); - if (timer == TIMER3C) cbi(TCCR3A, COM3C1); - if (timer == TIMER4A) cbi(TCCR4A, COM4A1); - if (timer == TIMER4B) cbi(TCCR4A, COM4B1); - if (timer == TIMER4C) cbi(TCCR4A, COM4C1); - if (timer == TIMER5A) cbi(TCCR5A, COM5A1); - if (timer == TIMER5B) cbi(TCCR5A, COM5B1); - if (timer == TIMER5C) cbi(TCCR5A, COM5C1); -#endif + switch(timer) + { + #if defined(TCCR1A) && defined(COM1A1) + case TIMER1A: cbi(TCCR1A, COM1A1); break; + #endif + #if defined(TCCR1A) && defined(COM1B1) + case TIMER1B: cbi(TCCR1A, COM1B1); break; + #endif + + //#if defined(__AVR_ATmega8__) || defined(__AVR_ATmega128__) + #if defined(TCCR2) && defined(COM21) + case TIMER2: cbi(TCCR2, COM21); break; + #endif + + #if defined(TCCR0A) && defined(COM0A1) + case TIMER0A: cbi(TCCR0A, COM0A1); break; + #endif + + #if defined(TIMER0B) && defined(COM0B1) + case TIMER0B: cbi(TCCR0A, COM0B1); break; + #endif + #if defined(TCCR2A) && defined(COM2A1) + case TIMER2A: cbi(TCCR2A, COM2A1); break; + #endif + #if defined(TCCR2A) && defined(COM2B1) + case TIMER2B: cbi(TCCR2A, COM2B1); break; + #endif + + //#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) + #if defined(TCCR3A) && defined(COM3A1) + case TIMER3A: cbi(TCCR3A, COM3A1); break; + #endif + #if defined(TCCR3A) && defined(COM3B1) + case TIMER3B: cbi(TCCR3A, COM3B1); break; + #endif + #if defined(TCCR3A) && defined(COM3C1) + case TIMER3C: cbi(TCCR3A, COM3C1); break; + #endif + + #if defined(TCCR4A) && defined(COM4A1) + case TIMER4A: cbi(TCCR4A, COM4A1); break; + #endif + #if defined(TCCR4A) && defined(COM4B1) + case TIMER4B: cbi(TCCR4A, COM4B1); break; + #endif + #if defined(TCCR4A) && defined(COM4C1) + case TIMER4C: cbi(TCCR4A, COM4C1); break; + #endif + #if defined(TCCR5A) + case TIMER5A: cbi(TCCR5A, COM5A1); break; + case TIMER5B: cbi(TCCR5A, COM5B1); break; + case TIMER5C: cbi(TCCR5A, COM5C1); break; + #endif + } + + +//* +//* old code +// if (timer == TIMER1A) cbi(TCCR1A, COM1A1); +// if (timer == TIMER1B) cbi(TCCR1A, COM1B1); +// +//#if defined(__AVR_ATmega8__) +// if (timer == TIMER2) cbi(TCCR2, COM21); +//#else +// if (timer == TIMER0A) cbi(TCCR0A, COM0A1); +// if (timer == TIMER0B) cbi(TCCR0A, COM0B1); +// if (timer == TIMER2A) cbi(TCCR2A, COM2A1); +// if (timer == TIMER2B) cbi(TCCR2A, COM2B1); +//#endif +// +//#if defined(__AVR_ATmega1280__) +// if (timer == TIMER3A) cbi(TCCR3A, COM3A1); +// if (timer == TIMER3B) cbi(TCCR3A, COM3B1); +// if (timer == TIMER3C) cbi(TCCR3A, COM3C1); +// if (timer == TIMER4A) cbi(TCCR4A, COM4A1); +// if (timer == TIMER4B) cbi(TCCR4A, COM4B1); +// if (timer == TIMER4C) cbi(TCCR4A, COM4C1); +// if (timer == TIMER5A) cbi(TCCR5A, COM5A1); +// if (timer == TIMER5B) cbi(TCCR5A, COM5B1); +// if (timer == TIMER5C) cbi(TCCR5A, COM5C1); +//#endif } +//********************************************************************************* void digitalWrite(uint8_t pin, uint8_t val) { uint8_t timer = digitalPinToTimer(pin); @@ -112,6 +186,7 @@ void digitalWrite(uint8_t pin, uint8_t val) } } +//********************************************************************************* int digitalRead(uint8_t pin) { uint8_t timer = digitalPinToTimer(pin); From 5e9dcffd443a446972c5981fbbf849f39f434158 Mon Sep 17 00:00:00 2001 From: Mark Sproul Date: Wed, 10 Nov 2010 20:23:47 -0500 Subject: [PATCH 6/6] issue 392 bug with git status! in code --- .../arduino/bootloaders/stk500v2/stk500boot.c | 183 ++- .../stk500v2/stk500boot_v2_mega2560.hex | 1015 +++++++++-------- 2 files changed, 650 insertions(+), 548 deletions(-) diff --git a/hardware/arduino/bootloaders/stk500v2/stk500boot.c b/hardware/arduino/bootloaders/stk500v2/stk500boot.c index 13dec895182..8b1d0d7a968 100755 --- a/hardware/arduino/bootloaders/stk500v2/stk500boot.c +++ b/hardware/arduino/bootloaders/stk500v2/stk500boot.c @@ -79,6 +79,8 @@ Description: add timeout feature like previous Wiring bootloader //* Jul 29, 2010 Added recchar_timeout for timing out on bootloading //* Aug 23, 2010 Added support for atmega2561 //* Aug 26, 2010 Removed support for BOOT_BY_SWITCH +//* Sep 8, 2010 Added support for atmega16 +//* Nov 9, 2010 Fixed bug that 3 !!! in code would cause it to jump to monitor //************************************************************************ @@ -95,7 +97,9 @@ Description: add timeout feature like previous Wiring bootloader #include "command.h" -#if defined(_MEGA_BOARD_) || defined(_BOARD_AMBER128_) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) || defined(__AVR_ATmega2561__) +#if defined(_MEGA_BOARD_) || defined(_BOARD_AMBER128_) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) \ + || defined(__AVR_ATmega2561__) || defined(__AVR_ATmega1284P__) || defined(ENABLE_MONITOR) + #undef ENABLE_MONITOR #define ENABLE_MONITOR static void RunMonitor(void); #endif @@ -131,8 +135,8 @@ Description: add timeout feature like previous Wiring bootloader #define PROGLED_PORT PORTD #define PROGLED_DDR DDRD #define PROGLED_PIN PINE7 -#elif defined( _CEREBOTPLUS_BOARD_ ) - //* this is for the Cerebot 2560 board +#elif defined( _CEREBOTPLUS_BOARD_ ) || defined(_CEREBOT_II_BOARD_) + //* this is for the Cerebot 2560 board and the Cerebot-ii //* onbarod leds are on PORTE4-7 #define PROGLED_PORT PORTE #define PROGLED_DDR DDRE @@ -149,6 +153,31 @@ Description: add timeout feature like previous Wiring bootloader #define PROGLED_PORT PORTA #define PROGLED_DDR DDRA #define PROGLED_PIN PINA3 +#elif defined( BOARD_MEGA16 ) + //* onbarod led is PORTA7 + #define PROGLED_PORT PORTA + #define PROGLED_DDR DDRA + #define PROGLED_PIN PINA7 + #define UART_BAUDRATE_DOUBLE_SPEED 0 + +#elif defined( _BOARD_BAHBOT_ ) + //* dosent have an onboard LED but this is what will probably be added to this port + #define PROGLED_PORT PORTB + #define PROGLED_DDR DDRB + #define PROGLED_PIN PINB0 + +#elif defined( _BOARD_ROBOTX_ ) + #define PROGLED_PORT PORTB + #define PROGLED_DDR DDRB + #define PROGLED_PIN PINB6 +#elif defined( _BOARD_CUSTOM1284_ ) + #define PROGLED_PORT PORTD + #define PROGLED_DDR DDRD + #define PROGLED_PIN PIND5 +#elif defined( _AVRLIP_ ) + #define PROGLED_PORT PORTB + #define PROGLED_DDR DDRB + #define PROGLED_PIN PINB5 #else #define PROGLED_PORT PORTG #define PROGLED_DDR DDRG @@ -164,6 +193,7 @@ Description: add timeout feature like previous Wiring bootloader #define F_CPU 16000000UL #endif +#define _BLINK_LOOP_COUNT_ (F_CPU / 2250) /* * UART Baudrate, AVRStudio AVRISP only accepts 115200 bps */ @@ -228,12 +258,30 @@ Description: add timeout feature like previous Wiring bootloader #define SIGNATURE_BYTES 0x1E9801 #elif defined (__AVR_ATmega2561__) #define SIGNATURE_BYTES 0x1e9802 +#elif defined (__AVR_ATmega1284P__) + #define SIGNATURE_BYTES 0x1e9705 +#elif defined (__AVR_ATmega640__) + #define SIGNATURE_BYTES 0x1e9608 +#elif defined (__AVR_ATmega64__) + #define SIGNATURE_BYTES 0x1E9602 + #else #error "no signature definition for MCU available" #endif -#if defined(__AVR_ATmega8__) || defined(__AVR_ATmega16__) || defined(__AVR_ATmega32__) \ +#if defined(_BOARD_ROBOTX_) + #define UART_BAUD_RATE_LOW UBRR1L + #define UART_STATUS_REG UCSR1A + #define UART_CONTROL_REG UCSR1B + #define UART_ENABLE_TRANSMITTER TXEN1 + #define UART_ENABLE_RECEIVER RXEN1 + #define UART_TRANSMIT_COMPLETE TXC1 + #define UART_RECEIVE_COMPLETE RXC1 + #define UART_DATA_REG UDR1 + #define UART_DOUBLE_SPEED U2X1 + +#elif defined(__AVR_ATmega8__) || defined(__AVR_ATmega16__) || defined(__AVR_ATmega32__) \ || defined(__AVR_ATmega8515__) || defined(__AVR_ATmega8535__) /* ATMega8 with one USART */ #define UART_BAUD_RATE_LOW UBRRL @@ -258,6 +306,17 @@ Description: add timeout feature like previous Wiring bootloader #define UART_RECEIVE_COMPLETE RXC0 #define UART_DATA_REG UDR0 #define UART_DOUBLE_SPEED U2X0 +#elif defined(UBRR0L) && defined(UCSR0A) && defined(TXEN0) + /* ATMega with two USART, use UART0 */ + #define UART_BAUD_RATE_LOW UBRR0L + #define UART_STATUS_REG UCSR0A + #define UART_CONTROL_REG UCSR0B + #define UART_ENABLE_TRANSMITTER TXEN0 + #define UART_ENABLE_RECEIVER RXEN0 + #define UART_TRANSMIT_COMPLETE TXC0 + #define UART_RECEIVE_COMPLETE RXC0 + #define UART_DATA_REG UDR0 + #define UART_DOUBLE_SPEED U2X0 #else #error "no UART definition for MCU available" #endif @@ -323,26 +382,16 @@ void __jumpMain(void) asm volatile ( ".set __stack, %0" :: "i" (RAMEND) ); -// ldi r16,high(RAMEND) -// out SPH,r16 ; Set stack pointer to top of RAM +//* et stack pointer to top of RAM -// asm volatile ( "ldi 16, 0x10"); asm volatile ( "ldi 16, %0" :: "i" (RAMEND >> 8) ); -// asm volatile ( "out 0x3E,16"); -// asm volatile ( "out %0,16" :: "i" (SPH_REG) ); asm volatile ( "out %0,16" :: "i" (AVR_STACK_POINTER_HI_ADDR) ); -// asm volatile ( "ldi 16, 0x00"); asm volatile ( "ldi 16, %0" :: "i" (RAMEND & 0x0ff) ); -// asm volatile ( "out 0x3d,16"); -// asm volatile ( "out %0,16" :: "i" (SPL_REG) ); asm volatile ( "out %0,16" :: "i" (AVR_STACK_POINTER_LO_ADDR) ); - - asm volatile ( "clr __zero_reg__" ); // GCC depends on register r1 set to 0 asm volatile ( "out %0, __zero_reg__" :: "I" (_SFR_IO_ADDR(SREG)) ); // set SREG to 0 -// asm volatile ( "rjmp main"); // jump to main() asm volatile ( "jmp main"); // jump to main() } @@ -403,7 +452,7 @@ uint32_t count = 0; if (count > MAX_TIME_COUNT) { unsigned int data; - #if (FLASHEND > 0x0FFFF) + #if (FLASHEND > 0x10000) data = pgm_read_word_far(0); //* get the first word of the user program #else data = pgm_read_word_near(0); //* get the first word of the user program @@ -442,7 +491,16 @@ int main(void) unsigned long boot_timer; unsigned int boot_state; #ifdef ENABLE_MONITOR - unsigned int exPointCntr = 0; + unsigned int exPointCntr = 0; + unsigned int rcvdCharCntr = 0; +#endif + +#if 1 + asm volatile ( ".set __stack, %0" :: "i" (RAMEND) ); + asm volatile ( "ldi 16, %0" :: "i" (RAMEND >> 8) ); + asm volatile ( "out %0,16" :: "i" (AVR_STACK_POINTER_HI_ADDR) ); + asm volatile ( "ldi 16, %0" :: "i" (RAMEND & 0x0ff) ); + asm volatile ( "out %0,16" :: "i" (AVR_STACK_POINTER_LO_ADDR) ); #endif @@ -450,7 +508,7 @@ int main(void) boot_state = 0; #ifdef BLINK_LED_WHILE_WAITING - boot_timeout = 20000; //* should be about 1 second + boot_timeout = 90000; //* should be about 4 seconds // boot_timeout = 170000; #else boot_timeout = 3500000; // 7 seconds , approx 2us per step when optimize "s" @@ -516,7 +574,7 @@ int main(void) boot_state = 1; // (after ++ -> boot_state=2 bootloader timeout, jump to main 0x00000 ) } #ifdef BLINK_LED_WHILE_WAITING - if ((boot_timer % 7000) == 0) + if ((boot_timer % _BLINK_LOOP_COUNT_) == 0) { //* toggle the LED PROGLED_PORT ^= (1< 0x10000) data = pgm_read_word_far(address); - #else + #else data = pgm_read_word_near(address); - #endif + #endif *p++ = (unsigned char)data; //LSB *p++ = (unsigned char)(data >> 8); //MSB address += 2; // Select next word in memory @@ -1056,6 +1118,8 @@ unsigned long gEepromIndex; #define true 1 #define false 0 +#include "avr_cpunames.h" +/* #if defined(__AVR_ATmega128__) #define kCPU_NAME "ATmega128" #elif defined(__AVR_ATmega1280__) @@ -1066,6 +1130,16 @@ unsigned long gEepromIndex; #define kCPU_NAME "ATmega2560" #elif defined(__AVR_ATmega2561__) #define kCPU_NAME "ATmega2561" +#elif defined(__AVR_ATmega1284P__) + #define kCPU_NAME "ATmega1284P" +#elif defined(__AVR_ATmega640__) + #define kCPU_NAME "ATmega640" +#else + #error cpu name not defined +#endif +*/ +#ifndef _AVR_CPU_NAME_ + #error cpu name not defined #endif #ifdef _VECTORS_SIZE @@ -1077,8 +1151,8 @@ unsigned long gEepromIndex; void PrintDecInt(int theNumber, int digitCnt); -#ifdef kCPU_NAME - prog_char gTextMsg_CPU_Name[] PROGMEM = kCPU_NAME; +#ifdef _AVR_CPU_NAME_ + prog_char gTextMsg_CPU_Name[] PROGMEM = _AVR_CPU_NAME_; #else prog_char gTextMsg_CPU_Name[] PROGMEM = "UNKNOWN"; #endif @@ -1086,16 +1160,16 @@ void PrintDecInt(int theNumber, int digitCnt); prog_char gTextMsg_Explorer[] PROGMEM = "Arduino explorer stk500V2 by MLS"; prog_char gTextMsg_Prompt[] PROGMEM = "Bootloader>"; prog_char gTextMsg_HUH[] PROGMEM = "Huh?"; - prog_char gTextMsg_COMPILED_ON[] PROGMEM = "Compiled on = "; - prog_char gTextMsg_CPU_Type[] PROGMEM = "CPU Type = "; - prog_char gTextMsg_AVR_ARCH[] PROGMEM = "__AVR_ARCH__ = "; - prog_char gTextMsg_AVR_LIBC[] PROGMEM = "AVR LibC Ver = "; - prog_char gTextMsg_GCC_VERSION[] PROGMEM = "GCC Version = "; - prog_char gTextMsg_CPU_SIGNATURE[] PROGMEM = "CPU signature= "; - prog_char gTextMsg_FUSE_BYTE_LOW[] PROGMEM = "Low fuse = "; - prog_char gTextMsg_FUSE_BYTE_HIGH[] PROGMEM = "High fuse = "; - prog_char gTextMsg_FUSE_BYTE_EXT[] PROGMEM = "Ext fuse = "; - prog_char gTextMsg_FUSE_BYTE_LOCK[] PROGMEM = "Lock fuse = "; + prog_char gTextMsg_COMPILED_ON[] PROGMEM = "Compiled on = "; + prog_char gTextMsg_CPU_Type[] PROGMEM = "CPU Type = "; + prog_char gTextMsg_AVR_ARCH[] PROGMEM = "__AVR_ARCH__= "; + prog_char gTextMsg_AVR_LIBC[] PROGMEM = "AVR LibC Ver= "; + prog_char gTextMsg_GCC_VERSION[] PROGMEM = "GCC Version = "; + prog_char gTextMsg_CPU_SIGNATURE[] PROGMEM = "CPU ID = "; + prog_char gTextMsg_FUSE_BYTE_LOW[] PROGMEM = "Low fuse = "; + prog_char gTextMsg_FUSE_BYTE_HIGH[] PROGMEM = "High fuse = "; + prog_char gTextMsg_FUSE_BYTE_EXT[] PROGMEM = "Ext fuse = "; + prog_char gTextMsg_FUSE_BYTE_LOCK[] PROGMEM = "Lock fuse = "; prog_char gTextMsg_GCC_DATE_STR[] PROGMEM = __DATE__; prog_char gTextMsg_AVR_LIBC_VER_STR[] PROGMEM = __AVR_LIBC_VERSION_STRING__; prog_char gTextMsg_GCC_VERSION_STR[] PROGMEM = __VERSION__; @@ -1109,13 +1183,13 @@ void PrintDecInt(int theNumber, int digitCnt); prog_char gTextMsg_SPACE[] PROGMEM = " "; prog_char gTextMsg_WriteToEEprom[] PROGMEM = "Writting EE"; prog_char gTextMsg_ReadingEEprom[] PROGMEM = "Reading EE"; - prog_char gTextMsg_EEPROMerrorCnt[] PROGMEM = "eeprom error count="; + prog_char gTextMsg_EEPROMerrorCnt[] PROGMEM = "EE err cnt="; prog_char gTextMsg_PORT[] PROGMEM = "PORT"; //************************************************************************ //* Help messages - prog_char gTextMsg_HELP_MSG_0[] PROGMEM = "0=Zero address ctrs"; + prog_char gTextMsg_HELP_MSG_0[] PROGMEM = "0=Zero addr"; prog_char gTextMsg_HELP_MSG_QM[] PROGMEM = "?=CPU stats"; prog_char gTextMsg_HELP_MSG_AT[] PROGMEM = "@=EEPROM test"; prog_char gTextMsg_HELP_MSG_B[] PROGMEM = "B=Blink LED"; @@ -1123,7 +1197,8 @@ void PrintDecInt(int theNumber, int digitCnt); prog_char gTextMsg_HELP_MSG_F[] PROGMEM = "F=Dump FLASH"; prog_char gTextMsg_HELP_MSG_H[] PROGMEM = "H=Help"; prog_char gTextMsg_HELP_MSG_L[] PROGMEM = "L=List I/O Ports"; - prog_char gTextMsg_HELP_MSG_Q[] PROGMEM = "Q=Quit & jump to user pgm"; +// prog_char gTextMsg_HELP_MSG_Q[] PROGMEM = "Q=Quit & jump to user pgm"; + prog_char gTextMsg_HELP_MSG_Q[] PROGMEM = "Q=Quit"; prog_char gTextMsg_HELP_MSG_R[] PROGMEM = "R=Dump RAM"; prog_char gTextMsg_HELP_MSG_V[] PROGMEM = "V=show interrupt Vectors"; prog_char gTextMsg_HELP_MSG_Y[] PROGMEM = "Y=Port blink"; @@ -1142,7 +1217,11 @@ char theChar; while (theChar != 0) { + #if (FLASHEND > 0x10000) theChar = pgm_read_byte_far((uint32_t)dataPtr + ii); + #else + theChar = pgm_read_byte_near((uint32_t)dataPtr + ii); + #endif if (theChar != 0) { sendchar(theChar); @@ -1388,7 +1467,11 @@ unsigned char *ramPtr; switch(dumpWhat) { case kDUMP_FLASH: + #if (FLASHEND > 0x10000) theValue = pgm_read_byte_far(myAddressPointer); + #else + theValue = pgm_read_byte_near(myAddressPointer); + #endif break; case kDUMP_EEPROM: @@ -1435,7 +1518,11 @@ int errorCount; PrintFromPROGMEMln(gTextMsg_WriteToEEprom, 0); PrintNewLine(); ii = 0; +#if (FLASHEND > 0x10000) while (((theChar = pgm_read_byte_far(gTextMsg_Explorer + ii)) != '*') && (ii < 512)) +#else + while (((theChar = pgm_read_byte_near(gTextMsg_Explorer + ii)) != '*') && (ii < 512)) +#endif { eeprom_write_byte((uint8_t *)ii, theChar); if (theChar == 0) @@ -1456,7 +1543,11 @@ int errorCount; PrintNewLine(); errorCount = 0; ii = 0; +#if (FLASHEND > 0x10000) while (((theChar = pgm_read_byte_far(gTextMsg_Explorer + ii)) != '*') && (ii < 512)) +#else + while (((theChar = pgm_read_byte_near(gTextMsg_Explorer + ii)) != '*') && (ii < 512)) +#endif { theEEPROMchar = eeprom_read_byte((uint8_t *)ii); if (theEEPROMchar == 0) @@ -1534,12 +1625,18 @@ unsigned long absoluteAddr; //* the AVR is LITTLE ENDIAN, swap the byte order + #if (FLASHEND > 0x10000) byte1 = pgm_read_byte_far(myMemoryPtr++); byte2 = pgm_read_byte_far(myMemoryPtr++); - word1 = (byte2 << 8) + byte1; - byte3 = pgm_read_byte_far(myMemoryPtr++); byte4 = pgm_read_byte_far(myMemoryPtr++); + #else + byte1 = pgm_read_byte_near(myMemoryPtr++); + byte2 = pgm_read_byte_near(myMemoryPtr++); + byte3 = pgm_read_byte_near(myMemoryPtr++); + byte4 = pgm_read_byte_near(myMemoryPtr++); + #endif + word1 = (byte2 << 8) + byte1; word2 = (byte4 << 8) + byte3; @@ -1596,7 +1693,11 @@ unsigned long absoluteAddr; #if defined(_INTERRUPT_NAMES_DEFINED_) sendchar(0x20); + #if (FLASHEND > 0x10000) stringPointer = pgm_read_word_far(&(gInterruptNameTable[vectorIndex])); + #else + stringPointer = pgm_read_word_near(&(gInterruptNameTable[vectorIndex])); + #endif PrintFromPROGMEM((char *)stringPointer, 0); #endif PrintNewLine(); diff --git a/hardware/arduino/bootloaders/stk500v2/stk500boot_v2_mega2560.hex b/hardware/arduino/bootloaders/stk500v2/stk500boot_v2_mega2560.hex index 4f366997c8d..b0c80a465fb 100644 --- a/hardware/arduino/bootloaders/stk500v2/stk500boot_v2_mega2560.hex +++ b/hardware/arduino/bootloaders/stk500v2/stk500boot_v2_mega2560.hex @@ -1,513 +1,514 @@ :020000023000CC -:10E000000D94F6F20D941FF30D941FF30D941FF36E -:10E010000D941FF30D941FF30D941FF30D941FF334 -:10E020000D941FF30D941FF30D941FF30D941FF324 -:10E030000D941FF30D941FF30D941FF30D941FF314 -:10E040000D941FF30D941FF30D941FF30D941FF304 -:10E050000D941FF30D941FF30D941FF30D941FF3F4 -:10E060000D941FF30D941FF30D941FF30D941FF3E4 -:10E070000D941FF30D941FF30D941FF30D941FF3D4 -:10E080000D941FF30D941FF30D941FF30D941FF3C4 -:10E090000D941FF30D941FF30D941FF30D941FF3B4 -:10E0A0000D941FF30D941FF30D941FF30D941FF3A4 -:10E0B0000D941FF30D941FF30D941FF30D941FF394 -:10E0C0000D941FF30D941FF30D941FF30D941FF384 -:10E0D0000D941FF30D941FF30D941FF30D941FF374 -:10E0E0000D941FF341546D65676132353630004140 +:10E000000D94DFF20D9408F30D9408F30D9408F3CA +:10E010000D9408F30D9408F30D9408F30D9408F390 +:10E020000D9408F30D9408F30D9408F30D9408F380 +:10E030000D9408F30D9408F30D9408F30D9408F370 +:10E040000D9408F30D9408F30D9408F30D9408F360 +:10E050000D9408F30D9408F30D9408F30D9408F350 +:10E060000D9408F30D9408F30D9408F30D9408F340 +:10E070000D9408F30D9408F30D9408F30D9408F330 +:10E080000D9408F30D9408F30D9408F30D9408F320 +:10E090000D9408F30D9408F30D9408F30D9408F310 +:10E0A0000D9408F30D9408F30D9408F30D9408F300 +:10E0B0000D9408F30D9408F30D9408F30D9408F3F0 +:10E0C0000D9408F30D9408F30D9408F30D9408F3E0 +:10E0D0000D9408F30D9408F30D9408F30D9408F3D0 +:10E0E0000D9408F341546D65676132353630004157 :10E0F000726475696E6F206578706C6F72657220DE :10E1000073746B3530305632206279204D4C530099 :10E11000426F6F746C6F616465723E004875683F52 -:10E1200000436F6D70696C6564206F6E20203D2028 -:10E1300000435055205479706520202020203D2038 -:10E14000005F5F4156525F415243485F5F203D2070 -:10E1500000415652204C69624320566572203D2092 -:10E16000004743432056657273696F6E20203D203F -:10E1700000435055207369676E61747572653D2068 -:10E18000004C6F77206675736520202020203D208D -:10E1900000486967682066757365202020203D204F -:10E1A00000457874206675736520202020203D206E -:10E1B000004C6F636B2066757365202020203D2026 -:10E1C00000536570202039203230313000312E3636 -:10E1D0002E3700342E332E33005623202020414486 -:10E1E00044522020206F7020636F6465202020201F -:10E1F00020696E737472756374696F6E20616464F4 -:10E2000072202020496E74657272757074006E6F92 -:10E2100020766563746F7200726A6D702020006AE8 -:10E220006D7020005768617420706F72743A0050EE -:10E230006F7274206E6F7420737570706F72746576 -:10E2400064004D7573742062652061206C65747480 -:10E2500065720020005772697474696E67204545C5 -:10E260000052656164696E6720454500656570729E -:10E270006F6D206572726F7220636F756E743D00F2 -:10E28000504F525400303D5A65726F206164647281 -:10E290006573732063747273003F3D435055207360 -:10E2A0007461747300403D454550524F4D20746574 -:10E2B000737400423D426C696E6B204C45440045CE -:10E2C0003D44756D7020454550524F4D00463D44CC -:10E2D000756D7020464C41534800483D48656C7050 -:10E2E000004C3D4C69737420492F4F20506F72745D -:10E2F0007300513D517569742026206A756D702038 -:10E30000746F20757365722070676D00523D44759F -:10E310006D702052414D00563D73686F7720696ED5 -:10E320007465727275707420566563746F727300D1 -:10E33000593D506F727420626C696E6B002A0052F6 -:10E340004553455400494E543000494E543100491C -:10E350004E543200494E543300494E543400494E15 -:10E36000543500494E543600494E54370050434905 -:10E370004E5430005043494E5431005043494E549E -:10E3800032005744540054494D45523020434F4DBC -:10E3900050410054494D45523020434F4D504200AA -:10E3A00054494D455230204F56460054494D455230 -:10E3B0003120434150540054494D45523120434F80 -:10E3C0004D50410054494D45523120434F4D50422C -:10E3D0000054494D45523120434F4D50430054495C -:10E3E0004D455231204F56460054494D455232203A -:10E3F000434F4D50410054494D45523220434F4DFB -:10E4000050420054494D455232204F56460054491F -:10E410004D45523320434150540054494D455233E9 -:10E4200020434F4D50410054494D45523320434FF6 -:10E430004D50420054494D45523320434F4D5043B7 -:10E440000054494D455233204F56460054494D45DE -:10E45000523420434150540054494D4552342043D6 -:10E460004F4D50410054494D45523420434F4D507B -:10E47000420054494D45523420434F4D50430054BF -:10E48000494D455234204F56460054494D4552356A -:10E4900020434150540054494D45523520434F4D7F -:10E4A00050410054494D45523520434F4D50420094 -:10E4B00054494D45523520434F4D50430054494D2A -:10E4C000455235204F564600555341525430205244 -:10E4D000580055534152543020554452450055532D -:10E4E0004152543020545800555341525431205217 -:10E4F000580055534152543120554452450055530C -:10E5000041525431205458005553415254322052F4 -:10E5100058005553415254322055445245005553EA -:10E5200041525432205458005553415254332052D2 -:10E5300058005553415254332055445245005553C9 -:10E5400041525433205458005350492053544300EF -:10E5500041444300414E414C4F4720434F4D5000F2 -:10E560004545205245414459005457490053504DA8 -:10E57000205245414459002A003FE345E34AE34F16 -:10E58000E354E359E35EE363E368E36DE374E37B41 -:10E59000E382E3E9E3F6E303E4ABE3B7E3C4E3D107 -:10E5A000E3DEE386E393E3A0E348E5C8E4D2E4DEF8 -:10E5B000E454E550E560E50EE41AE427E434E44170 -:10E5C000E4E8E4F2E4FEE469E56DE54CE458E46572 -:10E5D000E472E47FE48AE496E4A3E4B0E4BDE408F2 -:10E5E000E512E51EE528E532E53EE50011241FBEF3 -:10E5F000CFEFD1E2DEBFCDBF01E00CBF12E0A0E063 -:10E60000B2E0EAEDFFEF03E00BBF02C007900D920E -:10E61000A030B107D9F712E0A0E0B2E001C01D922E -:10E62000AC30B107E1F70F94FBF40D94EBFF01E27E -:10E630000EBF0FEF0DBF11241FBE0D94FBF40D9400 -:10E6400000F020E030E040ED57E005C0FA013197DE -:10E65000F1F72F5F3F4F28173907C0F308959C014A -:10E66000442737FD4095542FDA01C901860F911DCB -:10E67000A11DB11DABBFFC018791882369F0809378 -:10E68000C6008091C00086FFFCCF8091C0008064EE -:10E690008093C0006F5FE8CF08958DE08093C6003F -:10E6A0008091C00086FFFCCF8091C0008064809381 -:10E6B000C0008AE08093C6008091C00086FFFCCF36 -:10E6C0008091C00080648093C00008950F942FF360 -:10E6D0000F944DF30895FC019081992359F0909384 -:10E6E000C6008091C00086FFFCCF8091C00080648E -:10E6F0008093C0003196992379F70895282F982F99 -:10E7000092959F70892F805D8A3308F0895F80938E -:10E71000C6008091C00086FFFCCF8091C00080645D -:10E720008093C000822F8F70982F905D9A3308F0ED -:10E73000995F9093C6008091C00086FFFCCF8091C6 -:10E74000C00080648093C00008959C01FB01853661 -:10E7500091051CF46330710594F0C90164E670E022 -:10E760000F948CFF605D7F4F6093C6008091C00066 -:10E7700086FFFCCF8091C00080648093C0002B3066 -:10E78000310514F43297B4F0C90164E670E00F94D7 -:10E790008CFF6AE070E00F948CFF605D7F4F6093A8 -:10E7A000C6008091C00086FFFCCF8091C0008064CD -:10E7B0008093C000C9016AE070E00F948CFFC0969E -:10E7C0008093C6008091C00086FFFCCF8091C0007E -:10E7D00080648093C0000895282F277020642093C0 -:10E7E0007C0020917B0086958695869590E08170CF -:10E7F000907033E0880F991F3A95E1F7277F282B17 -:10E8000020937B0080917A00806480937A008091CD -:10E810007A0086FDFCCF2091780040917900942FFA -:10E8200080E030E0282B392BC90108951F93182F61 -:10E8300080E892EE60E00F942FF31093C600809171 -:10E84000C00086FFFCCF8091C00080648093C00030 -:10E850000F944DF31F9108952F923F924F925F9224 -:10E860006F927F928F929F92AF92BF92CF92DF92E0 -:10E87000EF92FF920F931F93DF93CF93CDB7DEB745 -:10E8800062970FB6F894DEBF0FBECDBF382E622E52 -:10E89000CA01DB015C016D01772460E2262E2E01A6 -:10E8A0000894411C511C8BC081E0A81680E0B8067A -:10E8B00081E0C80680E0D80628F0C601AA27BB2759 -:10E8C0000F947EF3BB27AD2D9C2D8B2D0F947EF3E3 -:10E8D0008A2D0F947EF32092C6008091C00086FF9F -:10E8E000FCCF8091C00080648093C0009DE2909333 -:10E8F000C6008091C00086FFFCCF8091C00080647C -:10E900008093C0002092C6008091C00086FFFCCF9B -:10E910008091C00080648093C000198286017501D7 -:10E9200088249924A1E03A1651F03A1620F0B2E07A -:10E930003B1661F409C00BBFF701779007C0C70110 -:10E940000F94D5FF782E02C0F7017080872D0F94A9 -:10E950007EF32092C6008091C00086FFFCCF80919C -:10E96000C00080648093C000872D8052F401EF7056 -:10E97000F0708F3520F4E40DF51D708204C0E40DB5 -:10E98000F51D8EE280830894E11CF11C011D111D10 -:10E990000894811C911C90E18916910409F0C2CF62 -:10E9A00080E190E0A0E0B0E0A80EB91ECA1EDB1E18 -:10E9B000198AC2010F946BF30F944DF36A94662089 -:10E9C00009F072CF62960FB6F894DEBF0FBECDBFCE -:10E9D000CF91DF911F910F91FF90EF90DF90CF903B -:10E9E000BF90AF909F908F907F906F905F904F906F -:10E9F0003F902F9008952F923F924F925F926F9287 -:10EA00007F928F929F92AF92BF92CF92DF92EF92BE -:10EA1000FF920F931F93DF93CF93CDB7DEB7CD5304 -:10EA2000D1400FB6F894DEBF0FBECDBF279A2F9A04 -:10EA30008091C00082608093C00080E18093C40018 -:10EA400088E18093C1000000EE24FF248701B4E038 -:10EA5000AB2EB12CCC24DD2424C0C5010197F1F7E5 -:10EA60000894E11CF11C011D111D21E2E2162EE4A7 -:10EA7000F20620E0020720E0120718F0A1E0CA2EFB -:10EA8000D12CC801B70128E53BE140E050E00F94EC -:10EA90009FFF611571058105910519F485B18058B5 -:10EAA00085B98091C00087FD03C0C114D104A9F2CB -:10EAB000A6014F5F5F4FC25EDE4F59834883CE5140 -:10EAC000D140C25EDE4F68817981CE51D140613044 -:10EAD000710511F00D946EFFC05DDE4F1982188232 -:10EAE000C053D14060E0C15DDE4F1882CF52D140AB -:10EAF000AA24BB24C05EDE4F188219821A821B82B0 -:10EB0000C052D140CE5CDE4F188219821A821B821D -:10EB1000C253D14080E090E0A0E0B0E0ABBFFC0188 -:10EB2000A791B691C45CDE4FB983A883CC53D14082 -:10EB30000D9469FFC25EDE4FE881F981CE51D1406C -:10EB4000319709F52091C600C25EDE4F1982188206 -:10EB5000CE51D14022C02F5F3F4F4F4F5F4F2130EA -:10EB6000F2E13F07FAE74F07F0E05F0780F0C45C8F -:10EB7000DE4F08811981CC53D1400F5F1F4F19F030 -:10EB8000EE27FF27099420E030E040E050E080913C -:10EB9000C00087FFE0CF2091C600213209F094C663 -:10EBA0000894A11CB11C33E0A316B10409F08EC671 -:10EBB00000E010E018C041E24093C6008091C00020 -:10EBC00086FFFCCF8091C00080648093C0002F5FDF -:10EBD0003F4F2931310579F70F944DF30F5F1F4FE8 -:10EBE0000530110519F020E030E0E5CF1092080261 -:10EBF0001092090210920A0210920B021092040263 -:10EC00001092050210920602109207021092000262 -:10EC10001092010210920202109203028FEE90EE07 -:10EC200060E00F9466F380E191EE60E00F942FF3C3 -:10EC30008091C00087FFFCCF9091C600903608F00D -:10EC40009F759032B8F09093C6008091C00086FF07 -:10EC5000FCCF8091C00080648093C00080E28093EC -:10EC6000C6008091C00086FFFCCF8091C000806408 -:10EC70008093C000983409F4DBC19934B8F492341D -:10EC800009F45DC1933458F4903319F1903308F4CA -:10EC900018C69F33A1F1903409F013C6BDC0953456 -:10ECA00009F474C1963409F00CC69CC1923509F47C -:10ECB0002FC2933538F49C3409F4F9C1913509F029 -:10ECC00000C61CC2963509F449C2993509F0F9C548 -:10ECD0009CC485E892EE62E00F9466F31092040201 -:10ECE000109205021092060210920702109208027A -:10ECF0001092090210920A0210920B0217C189E9C0 -:10ED000092EE62E00F9466F38FEE90EE60E00F9467 -:10ED100066F381E291EE60E00F942FF381EC91EEC7 -:10ED200060E00F9466F381E391EE60E00F942FF3BF -:10ED300084EE90EE60E00F9466F381E491EE60E083 -:10ED40000F942FF386E090E061E070E00F94A5F35C -:10ED50000F944DF381E691EE60E00F942FF383ED75 -:10ED600091EE60E00F9466F381E591EE60E00F9420 -:10ED70002FF38DEC91EE60E00F9466F381E791EE56 -:10ED800060E00F942FF38EE10F947EF388E90F94E7 -:10ED90007EF381E00F947EF30F944DF381E891EEC2 -:10EDA00060E00F942FF319E0E0E0F0E010935700DB -:10EDB000E4918E2F0F947EF30F944DF381E991EE41 -:10EDC00060E00F942FF3E3E0F0E010935700E4913C -:10EDD0008E2F0F947EF30F944DF381EA91EE60E055 -:10EDE0000F942FF3E2E0F0E010935700E4918E2FA0 -:10EDF0000F947EF30F944DF381EB91EE60E00F944E -:10EE00002FF3E1E0F0E0109357001491812F0F945D -:10EE10007EF30F944DF307CF85EA92EE62E00F94F4 -:10EE200066F385E592EE60E00F9466F30F944DF380 -:10EE300000E010E019C0C8016F2D0F94DDFFFF2026 -:10EE400031F483E592EE60E00F942FF30BC0F09263 -:10EE5000C6008091C00086FFFCCF8091C000806416 -:10EE60008093C0000F5F1F4FC80181519F41AA27A7 -:10EE700097FDA095BA2FABBFFC01F7905AE2F516AB -:10EE800021F062E000301607B1F60F944DF30F94B5 -:10EE90004DF381E692EE60E00F9466F30F944DF32C -:10EEA000CC24DD2400E010E01EC0C8010F94D5FF83 -:10EEB000F82E882331F483E592EE60E00F942FF36F -:10EEC0000BC08093C6008091C00086FFFCCF80916C -:10EED000C00080648093C000FE1419F00894C11C27 -:10EEE000D11C0F5F1F4FC80181519F41AA2797FD79 -:10EEF000A095BA2FABBFFC01E7907AE2E71621F0AC -:10EF000082E00030180789F60F944DF30F944DF30B -:10EF10008CE692EE60E00F942FF3C60161E070E0A2 -:10EF20000F94A5F30F944DF30F944DF3109200023C -:10EF300010920102109202021092030274CE83EB2F -:10EF400092EE62E00F9466F3279A2F9A16C02F98DC -:10EF500080E090E0E0EDF7E03197F1F7019684363C -:10EF60009105C1F72F9A80E090E0E0EDF7E031974E -:10EF7000F1F7019684369105C1F78091C00087FFB3 -:10EF8000E6CF8091C00087FFFCCF95C48FEB92EE57 -:10EF900062E00F9466F3409100025091010260918B -:10EFA00002027091030281E020E10F942CF4809121 -:10EFB000000290910102A0910202B09103028050E0 -:10EFC0009F4FAF4FBF4F8093000290930102A093D9 -:10EFD0000202B093030280509041A040B04008F478 -:10EFE00022CEA4CF8DEC92EE62E00F9466F34091B6 -:10EFF000040250910502609106027091070280E0C0 -:10F0000020E10F942CF48091040290910502A091CC -:10F010000602B091070280509F4FAF4FBF4F8093C1 -:10F02000040290930502A0930602B0930702FBCD61 -:10F030008AED92EE62E00F9466F385E892EE60E06E -:10F040000F9466F389E992EE60E00F9466F385EA27 -:10F0500092EE60E00F9466F383EB92EE60E00F9423 -:10F0600066F38FEB92EE60E00F9466F38DEC92EE18 -:10F0700060E00F9466F38AED92EE60E00F9466F321 -:10F0800081EE92EE60E00F9466F382EF92EE60E024 -:10F090000F9466F38CE093EE60E00F9466F387E1E3 -:10F0A00093EE60E00F9466F380E393EEB9CD81EECA -:10F0B00092EE62E00F9466F381E40F9416F482E41A -:10F0C0000F9416F483E40F9416F484E40F9416F46A -:10F0D00085E40F9416F486E40F9416F487E40F94F5 -:10F0E00016F488E40F9416F48AE40F9416F48BE473 -:10F0F0000F9416F48CE40F9416F495CD82EF92EEF3 -:10F1000062E00F9466F399249394AA24BB2445C427 -:10F110008CE093EE62E00F9466F340910802509108 -:10F12000090260910A0270910B0282E020E10F94C3 -:10F130002CF48091080290910902A0910A02B091EA -:10F140000B0280509F4FAF4FBF4F809308029093A8 -:10F150000902A0930A02B0930B0265CD87E193EEFA -:10F1600062E00F9466F384EE90EE60E00F9466F335 -:10F1700089ED91EE60E00F9466F309E715EECC5D42 -:10F18000DE4F19830883C452D1406624772443019B -:10F19000CA5DDE4F19821882C652D140A401930184 -:10F1A0005695479537952795C85DDE4F2883398357 -:10F1B0004A835B83C852D140CA5DDE4F4881598182 -:10F1C000C652D1404F5F5F4FCA5DDE4F59834883BF -:10F1D000C652D140CA0162E070E00F94A5F350E23C -:10F1E0005093C6008091C00086FFFCCF8091C00084 -:10F1F00080648093C0006DE26093C6008091C0007F -:10F2000086FFFCCF8091C00080648093C00070E2D4 -:10F210007093C6008091C00086FFFCCF8091C00033 -:10F2200080648093C000C85DDE4FE880F9800A8169 -:10F230001B81C852D140BB27A12F902F8F2D0F9437 -:10F240007EF3C85DDE4F8881C852D1400F947EF3B3 -:10F2500070E2F72EF092C6008091C00086FFFCCFCE -:10F260008091C00080648093C0000DE30093C600CD -:10F270008091C00086FFFCCF8091C00080648093A5 -:10F28000C00010E21093C6008091C00086FFFCCF42 -:10F290008091C00080648093C0008BBEF3012791F1 -:10F2A000C45DDE4F2883CC52D140A22EBB24CC2497 -:10F2B000DD240894611C711C811C911C8BBEF30120 -:10F2C0008791282E332444245524142D032DF22C09 -:10F2D000EE24EA0CFB1C0C1D1D1D0894611C711C06 -:10F2E000811C911C8BBEF3013791C35DDE4F3883C7 -:10F2F000CD52D1400894611C711C811C911C8BBEA5 -:10F30000F3014791C25DDE4F4883CE52D1402DEFCD -:10F310003FEF4FEF5FEF620E731E841E951E0F943A -:10F320007EF330E23093C6008091C00086FFFCCFB0 -:10F330008091C00080648093C000C45DDE4F8881EE -:10F34000CC52D1400F947EF340E24093C6008091AE -:10F35000C00086FFFCCF8091C00080648093C00015 -:10F36000C25DDE4F8881CE52D1400F947EF350E2D1 -:10F370005093C6008091C00086FFFCCF8091C000F2 -:10F3800080648093C000C35DDE4F8881CD52D14040 -:10F390000F947EF360E26093C6008091C00086FF08 -:10F3A000FCCF8091C00080648093C0007FEFE7169F -:10F3B0007FEFF70670E0070770E0170731F48EE083 -:10F3C00092EE60E00F942FF3DFC0D801C701807088 -:10F3D000907CA070B0708050904CA040B040D1F5AF -:10F3E0002FEF3FE340E050E0E222F3220423152315 -:10F3F000C85DDE4FA880B980CA80DB80C852D1408A -:10F40000AE0CBF1CC01ED11EAA0CBB1CCC1CDD1C2C -:10F4100088E192EE60E00F942FF3BB27A12F902F8D -:10F420008F2D0F947EF38E2D0F947EF330E2309368 -:10F43000C6008091C00086FFFCCF8091C000806430 -:10F440008093C0004EE34093C6008091C00086FFC9 -:10F45000FCCF87C06EE07EEF80E090E0E622F722EE -:10F46000082319237CE0E71674E9F70670E0070724 -:10F4700070E0170709F088C0C25DDE4F8881CE5268 -:10F48000D140E82EFF2400E010E0102F0F2DFE2CBD -:10F49000EE24C35DDE4F9881CD52D140E90EF11CC0 -:10F4A000011D111DD601C50181709070A070B07052 -:10F4B000DC0199278827E80EF91E0A1F1B1F20EF81 -:10F4C00030E040E050E0A222B322C422D522F1E194 -:10F4D000AA0CBB1CCC1CDD1CFA95D1F7EA0CFB1C5A -:10F4E0000C1D1D1D41E050E060E070E0242235223B -:10F4F00046225722E5E1220C331C441C551CEA9598 -:10F50000D1F7E20CF31C041D151D57016801AA0C6C -:10F51000BB1CCC1CDD1C8FE192EE60E00F942FF33E -:10F52000C801AA27BB270F947EF3BB27A12F902FDA -:10F530008F2D0F947EF38E2D0F947EF350E2509317 -:10F54000C6008091C00086FFFCCF8091C00080641F -:10F550008093C0006EE36093C6008091C00086FF78 -:10F56000FCCF8091C00080648093C000C601AA27B0 -:10F57000BB270F947EF3BB27AD2D9C2D8B2D0F94B5 -:10F580007EF38A2D0F947EF370E27093C600809113 -:10F59000C00086FFFCCF8091C00080648093C000D3 -:10F5A000CC5DDE4FE881F981C452D140CF01AA275A -:10F5B00097FDA095BA2FABBFFC018791969160E0B3 -:10F5C0000F942FF30F944DF3CC5DDE4F088119811A -:10F5D000C452D1400E5F1F4FCC5DDE4F19830883AC -:10F5E000C452D140CA5DDE4F28813981C652D14014 -:10F5F0002933310509F417CB44E050E060E070E0B6 -:10F60000640E751E861E971EC9CD80E393EE62E0E0 -:10F610000F9466F384E292EE60E00F942FF38091F2 -:10F62000C00087FFFCCF1091C6001F751093C60065 -:10F630008091C00086FFFCCF8091C00080648093E1 -:10F64000C0000F944DF3812F81548A3108F036C1E8 -:10F65000163409F495C0173490F4133409F44EC0ED -:10F66000143430F41134F1F0123409F01DC130C0FB -:10F67000143409F459C0153409F016C16BC01A349A -:10F6800009F4C4C01B3438F4173409F48FC018349B -:10F6900009F00AC1A1C01B3409F4D2C01C3409F01E -:10F6A00003C1E8C08FEF81B90DC082B1809582B9E6 -:10F6B00080E090E0E0EDF7E03197F1F70196883CCB -:10F6C0009105C1F78091C00087FFEFCF12B8EFC05E -:10F6D0008FEF84B90DC085B1809585B980E090E049 -:10F6E000E0EDF7E03197F1F70196883C9105C1F71D -:10F6F0008091C00087FFEFCF15B8D9C08FEF87B9D1 -:10F700000DC088B1809588B980E090E0E0EDF7E029 -:10F710003197F1F70196883C9105C1F78091C000BF -:10F7200087FFEFCF18B8C3C08FEF8AB90DC08BB178 -:10F7300080958BB980E090E0E0EDF7E03197F1F74C -:10F740000196883C9105C1F78091C00087FFEFCFFB -:10F750001BB8ADC08FEF8DB90DC08EB180958EB93D -:10F7600080E090E0E0EDF7E03197F1F70196883C1A -:10F770009105C1F78091C00087FFEFCF1EB897C0F9 -:10F780008FEF80BB0DC081B3809581BB80E090E09E -:10F79000E0EDF7E03197F1F70196883C9105C1F76C -:10F7A0008091C00087FFEFCF11BA81C08FEF83BB7C -:10F7B0000DC084B3809584BB80E090E0E0EDF7E07D -:10F7C0003197F1F70196883C9105C1F78091C0000F -:10F7D00087FFEFCF14BA6BC08FEF809301010FC08A -:10F7E0008091020180958093020180E090E0E0ED3D -:10F7F000F7E03197F1F70196883C9105C1F78091C8 -:10F80000C00087FFEDCF1092020151C08FEF8093AF -:10F8100004010FC08091050180958093050180E06F -:10F8200090E0E0EDF7E03197F1F70196883C910523 -:10F83000C1F78091C00087FFEDCF1092050137C05E -:10F840008FEF809307010FC080910801809580930E -:10F85000080180E090E0E0EDF7E03197F1F70196E4 -:10F86000883C9105C1F78091C00087FFEDCF1092D1 -:10F8700008011DC08FEF80930A010FC080910B011A -:10F88000809580930B0180E090E0E0EDF7E0319708 -:10F89000F1F70196883C9105C1F78091C00087FF80 -:10F8A000EDCF10920B0103C08FE292EEB9C98091A7 -:10F8B000C00087FFFCCF8091C600B5C982E492EEFC -:10F8C000AFC98CE191EEACC9AA24BB24933061F19D -:10F8D000943028F4913089F0923008F508C09530C2 -:10F8E000B1F1953040F1963009F053C04EC02B3144 -:10F8F00009F020C991E06BE11DC9213041F0C15DE3 -:10F90000DE4F5881CF52D140251709F002C362273C -:10F91000C15DDE4F2883CF52D14092E00BC9B22F98 -:10F92000A0E0622793E006C9822F90E0A82BB92BB4 -:10F93000622794E0FFC82E3009F0EBC2622795E001 -:10F94000C05DDE4F19821882C053D140F3C8E1E098 -:10F95000F0E0EC0FFD1FC05DDE4FE880F980C05382 -:10F96000D140EE0DFF1D208387010F5F1F4FC05D4B -:10F97000DE4F19830883C053D14062270A171B0743 -:10F9800009F0D8C8D80196E0D5C8261709F0C1C239 -:10F9900003C0973009F0CEC899248981833109F4D6 -:10F9A000FCC08431C8F4863009F4C2C0873050F4FA -:10F9B000823009F4F0C0833009F458C0813009F076 -:10F9C0000AC23EC0813109F462C0823108F0A6C08B -:10F9D000803109F000C2DFC0883109F472C089317A -:10F9E00050F4853109F4D9C0853108F477C18631E6 -:10F9F00009F0F1C173C18A3109F457C08A3108F4A2 -:10FA00007CC08B3109F446C08D3109F0E4C18D8191 -:10FA1000803311F090E00AC08F81882311F49EE1B9 -:10FA200005C0813011F091E001C098E91A821B8273 -:10FA30008D818C831D829E831F8227E030E0CFC1A1 -:10FA40001A8288E08B8381E48C8386E58D8382E54E -:10FA50008E8389E48F8383E5888780E589878FE5B6 -:10FA60008A8782E38B872BE030E0B9C18A818139B4 -:10FA700041F0823941F0803911F48FE005C080E017 -:10FA800003C082E001C08AE01A828B8344C09924BB -:10FA9000939481C08D81882311F48EE12CC0813034 -:10FAA00011F081E028C088E926C01A82E1E0F0E088 -:10FAB00089E08093570084918B831C8224E030E09E -:10FAC0008EC18B81803589F48C81883039F4E2E0F5 -:10FAD000F0E089E08093570084910DC0E0E0F0E011 -:10FAE00089E080935700849106C0E3E0F0E089E06C -:10FAF0008093570084911A82DFCF8D81836C99E0C7 -:10FB0000E1E0F0E0082E90935700E89507B600FC7E -:10FB1000FDCF1A821B8223E030E061C11A82CE5CE5 -:10FB2000DE4F188219821A821B82C253D14055C1FE -:10FB30008A8190E0A0E0B0E0582F442733272227A5 -:10FB40008B8190E0A0E0B0E0DC0199278827282B8A -:10FB5000392B4A2B5B2B8D8190E0A0E0B0E0282B65 -:10FB6000392B4A2B5B2B8C8190E0A0E0B0E0BA2FC0 -:10FB7000A92F982F8827282B392B4A2B5B2B220F54 -:10FB8000331F441F551FC05EDE4F288339834A83CD -:10FB90005B83C052D1401A8220C19A812B8183316C -:10FBA00049F0C05EDE4F488159816A817B81C05235 -:10FBB000D1408AC0CE5CDE4F488159816A817B8109 -:10FBC000C253D140403080EC580783E0680780E0A2 -:10FBD0007807F0F483E0FA0160935B0080935700AC -:10FBE000E89507B600FCFDCFCE5CDE4F4881598119 -:10FBF0006A817B81C253D14040505F4F6F4F7F4F2E -:10FC0000CE5CDE4F488359836A837B83C253D140E5 -:10FC1000C95CDE4F9883C753D140CA5CDE4F18825F -:10FC2000C653D140022F10E0CA5CDE4F6881798153 -:10FC3000C653D140062B172BC05EDE4F4881598139 -:10FC40006A817B81C052D140DE011B9631E08C91EC -:10FC500011962C9111971296C75CDE4F2883C953D9 -:10FC6000D140C85CDE4F1882C853D14090E0C85CD8 -:10FC7000DE4FE881F981C853D1408E2B9F2B0C01B8 -:10FC8000FA0160935B0030935700E89511244E5FB2 -:10FC90005F4F6F4F7F4F02501040C9F685E0C05E46 -:10FCA000DE4FE880F9800A811B81C052D140F70104 -:10FCB00000935B0080935700E89507B600FCFDCFEA -:10FCC00081E180935700E8951A82C05EDE4F488339 -:10FCD00059836A837B83C052D1407FC0FA80C55C60 -:10FCE000DE4FF882CB53D140C65CDE4F1882CA5338 -:10FCF000D1408B81C82EDD24C65CDE4F088119817E -:10FD0000CA53D140C02AD12A1A828981BE016D5FAF -:10FD10007F4F843121F59601C05EDE4FE880F98087 -:10FD20000A811B81C052D1400BBFF7018791969188 -:10FD3000DB018C9311969C936E5F7F4FD801C701B6 -:10FD40000296A11DB11DC05EDE4F88839983AA83F0 -:10FD5000BB83C052D14022503040F1F636C0C05E65 -:10FD6000DE4F288139814A815B81C052D14008949D -:10FD7000C108D108760100E010E00894C11CD11C34 -:10FD80000894E11CF11C011D111DE20EF31E041F5D -:10FD9000151F21BDBB27A52F942F832F82BD2F5F59 -:10FDA0003F4F4F4F5F4FF89A80B5DB018D93BD01F8 -:10FDB0002E153F054007510761F7C05EDE4F2883CF -:10FDC00039834A835B83C052D14096012D5F3F4FF8 -:10FDD000FB01108204C080EC8A8322E030E08BE1DA -:10FDE0008093C6008091C00086FFFCCF8091C00048 -:10FDF00080648093C000C15DDE4FF881CF52D14056 -:10FE0000F093C6008091C00086FFFCCF8091C000B7 -:10FE100080648093C000432F3093C6008091C0005F -:10FE200086FFFCCF8091C00080648093C000922F39 -:10FE30002093C6008091C00086FFFCCF8091C00057 -:10FE400080648093C0008EE08093C6008091C000E3 -:10FE500086FFFCCF8091C00080648093C00065E184 -:10FE6000C15DDE4FE880CF52D1406E2569276427FF -:10FE7000FE01319610C090819093C6008091C00021 -:10FE800086FFFCCF31968091C00080648093C000D3 -:10FE90006927215030402115310569F76093C6006C -:10FEA0008091C00086FFFCCF8091C0008064809369 -:10FEB000C00085B1805885B9992081F4C15DDE4FBD -:10FEC0000881CF52D1400F5FC15DDE4F0883CF5212 -:10FED000D14090E0A0E0B0E00D949AF527982F98DB -:10FEE00080E090E020ED37E0F9013197F1F70196DD -:10FEF00084369105C9F700008091C0008D7F809302 -:10FF0000C00081E180935700E895EE27FF27099410 -:10FF1000FFCF90E00D949AF597FB092E07260AD0A3 -:10FF200077FD04D02ED006D000201AF4709561958C -:10FF30007F4F0895F6F7909581959F4F0895A1E220 -:10FF40001A2EAA1BBB1BFD010DC0AA1FBB1FEE1F53 -:10FF5000FF1FA217B307E407F50720F0A21BB30B9E -:10FF6000E40BF50B661F771F881F991F1A9469F71A -:10FF700060957095809590959B01AC01BD01CF0176 -:10FF80000895AA1BBB1B51E107C0AA1FBB1FA617E0 -:10FF9000B70710F0A61BB70B881F991F5A95A9F732 -:10FFA00080959095BC01CD010895F999FECF92BD41 -:10FFB00081BDF89A992780B50895262FF999FECF2B -:10FFC0001FBA92BD81BD20BD0FB6F894FA9AF99A76 -:0AFFD0000FBE01960895F894FFCFCC +:10E1200000436F6D70696C6564206F6E203D200048 +:10E130004350552054797065202020203D20005FF9 +:10E140005F4156525F415243485F5F3D2000415658 +:10E1500052204C696243205665723D20004743437C +:10E160002056657273696F6E203D20004350552024 +:10E1700049442020202020203D20004C6F7720663D +:10E18000757365202020203D20004869676820665F +:10E190007573652020203D200045787420667573D6 +:10E1A00065202020203D20004C6F636B2066757336 +:10E1B000652020203D20004E6F7620313020323007 +:10E1C000313000312E362E3700342E332E330056A8 +:10E1D00023202020414444522020206F7020636F70 +:10E1E00064652020202020696E73747275637469E1 +:10E1F0006F6E2061646472202020496E74657272B3 +:10E20000757074006E6F20766563746F7200726A49 +:10E210006D702020006A6D70200057686174207056 +:10E220006F72743A00506F7274206E6F7420737541 +:10E2300070706F72746564004D7573742062652030 +:10E2400061206C6574746572002000577269747483 +:10E25000696E672045450052656164696E672045B7 +:10E26000450045452065727220636E743D00504F35 +:10E27000525400303D5A65726F2061646472003FF1 +:10E280003D43505520737461747300403D454550C3 +:10E29000524F4D207465737400423D426C696E6B41 +:10E2A000204C454400453D44756D70204545505215 +:10E2B0004F4D00463D44756D7020464C415348001B +:10E2C000483D48656C70004C3D4C69737420492F83 +:10E2D0004F20506F72747300513D51756974005234 +:10E2E0003D44756D702052414D00563D73686F7707 +:10E2F00020696E7465727275707420566563746FF0 +:10E30000727300593D506F727420626C696E6B00BD +:10E310002A00524553455400494E543000494E544A +:10E320003100494E543200494E543300494E543462 +:10E3300000494E543500494E543600494E5437007A +:10E340005043494E5430005043494E5431005043DD +:10E35000494E5432005744540054494D45523020E0 +:10E36000434F4D50410054494D45523020434F4D8D +:10E3700050420054494D455230204F5646005449B2 +:10E380004D45523120434150540054494D4552317E +:10E3900020434F4D50410054494D45523120434F89 +:10E3A0004D50420054494D45523120434F4D50434A +:10E3B0000054494D455231204F56460054494D4571 +:10E3C000523220434F4D50410054494D4552322066 +:10E3D000434F4D50420054494D455232204F56460E +:10E3E0000054494D45523320434150540054494D47 +:10E3F00045523320434F4D50410054494D4552330F +:10E4000020434F4D50420054494D45523320434F15 +:10E410004D50430054494D455233204F5646005409 +:10E42000494D45523420434150540054494D4552C2 +:10E430003420434F4D50410054494D455234204300 +:10E440004F4D50420054494D45523420434F4D509A +:10E45000430054494D455234204F56460054494DCF +:10E4600045523520434150540054494D45523520C2 +:10E47000434F4D50410054494D45523520434F4D77 +:10E4800050420054494D45523520434F4D504300B2 +:10E4900054494D455235204F56460055534152542C +:10E4A0003020525800555341525430205544524563 +:10E4B0000055534152543020545800555341525442 +:10E4C0003120525800555341525431205544524541 +:10E4D0000055534152543120545800555341525421 +:10E4E000322052580055534152543220554452451F +:10E4F0000055534152543220545800555341525400 +:10E5000033205258005553415254332055445245FC +:10E51000005553415254332054580053504920530E +:10E5200054430041444300414E414C4F4720434F28 +:10E530004D5000454520524541445900545749002B +:10E5400053504D205245414459002A0012E318E32C +:10E550001DE322E327E32CE331E336E33BE340E32F +:10E5600047E34EE355E3BCE3C9E3D6E37EE38AE346 +:10E5700097E3A4E3B1E359E366E373E31BE59BE4AC +:10E58000A5E4B1E427E523E533E5E1E3EDE3FAE3D0 +:10E5900007E414E4BBE4C5E4D1E43CE540E51FE452 +:10E5A0002BE438E445E452E45DE469E476E483E492 +:10E5B00090E4DBE4E5E4F1E4FBE405E511E5112496 +:10E5C0001FBECFEFD1E2DEBFCDBF01E00CBF12E036 +:10E5D000A0E0B2E0ECEEFFEF03E00BBF02C007905B +:10E5E0000D92A030B107D9F712E0A0E0B2E001C06F +:10E5F0001D92AC30B107E1F70F94E4F40D94F4FFF1 +:10E6000001E20EBF0FEF0DBF11241FBE0D94E4F405 +:10E610000D9400F020E030E040ED57E005C0FA0135 +:10E620003197F1F72F5F3F4F28173907C0F308954F +:10E630009C01442737FD4095542FDA01C901860F0C +:10E64000911DA11DB11DABBFFC018791882369F00D +:10E650008093C6008091C00086FFFCCF8091C000EF +:10E6600080648093C0006F5FE8CF08958DE0809351 +:10E67000C6008091C00086FFFCCF8091C0008064FE +:10E680008093C0008AE08093C6008091C00086FF1E +:10E69000FCCF8091C00080648093C00008950F94E7 +:10E6A00018F30F9436F30895FC019081992359F0E3 +:10E6B0009093C6008091C00086FFFCCF8091C0007F +:10E6C00080648093C0003196992379F70895282FAC +:10E6D000982F92959F70892F805D8A3308F0895F0B +:10E6E0008093C6008091C00086FFFCCF8091C0005F +:10E6F00080648093C000822F8F70982F905D9A3332 +:10E7000008F0995F9093C6008091C00086FFFCCF0F +:10E710008091C00080648093C00008959C01FB013B +:10E72000853691051CF46330710594F0C90164E6E7 +:10E7300070E00F9495FF605D7F4F6093C6008091FD +:10E74000C00086FFFCCF8091C00080648093C00031 +:10E750002B30310514F43297B4F0C90164E670E04F +:10E760000F9495FF6AE070E00F9495FF605D7F4F16 +:10E770006093C6008091C00086FFFCCF8091C000EE +:10E7800080648093C000C9016AE070E00F9495FF37 +:10E79000C0968093C6008091C00086FFFCCF809118 +:10E7A000C00080648093C0000895282F27702064E3 +:10E7B00020937C0020917B0086958695869590E03D +:10E7C0008170907033E0880F991F3A95E1F7277FA9 +:10E7D000282B20937B0080917A00806480937A00BC +:10E7E00080917A0086FDFCCF2091780040917900DD +:10E7F000942F80E030E0282B392BC90108951F9316 +:10E80000182F8EE692EE60E00F9418F31093C60076 +:10E810008091C00086FFFCCF8091C000806480930F +:10E82000C0000F9436F31F9108952F923F924F929C +:10E830005F926F927F928F929F92AF92BF92CF9290 +:10E84000DF92EF92FF920F931F93DF93CF93CDB799 +:10E85000DEB762970FB6F894DEBF0FBECDBF382E7D +:10E86000622ECA01DB015C016D01772460E2262E75 +:10E870002E010894411C511C8BC081E0A81680E039 +:10E88000B80681E0C80680E0D80628F0C601AA27AD +:10E89000BB270F9467F3BB27AD2D9C2D8B2D0F94B9 +:10E8A00067F38A2D0F9467F32092C6008091C00011 +:10E8B00086FFFCCF8091C00080648093C0009DE201 +:10E8C0009093C6008091C00086FFFCCF8091C0006D +:10E8D00080648093C0002092C6008091C00086FFB3 +:10E8E000FCCF8091C00080648093C00019828601B3 +:10E8F000750188249924A1E03A1651F03A1620F0C7 +:10E90000B2E03B1661F409C00BBFF701779007C076 +:10E91000C7010F94DEFF782E02C0F7017080872DAB +:10E920000F9467F32092C6008091C00086FFFCCF51 +:10E930008091C00080648093C000872D8052F401D4 +:10E94000EF70F0708F3520F4E40DF51D708204C077 +:10E95000E40DF51D8EE280830894E11CF11C011D7D +:10E96000111D0894811C911C90E18916910409F0F5 +:10E97000C2CF80E190E0A0E0B0E0A80EB91ECA1EB0 +:10E98000DB1E198AC2010F9454F30F9436F36A9474 +:10E99000662009F072CF62960FB6F894DEBF0FBE04 +:10E9A000CDBFCF91DF911F910F91FF90EF90DF903E +:10E9B000CF90BF90AF909F908F907F906F905F901F +:10E9C0004F903F902F9008952F923F924F925F92D9 +:10E9D0006F927F928F929F92AF92BF92CF92DF926F +:10E9E000EF92FF920F931F93DF93CF93CDB7DEB7D4 +:10E9F000CF53D1400FB6F894DEBF0FBECDBF01E2BA +:10EA00000EBF0FEF0DBF279A2F9A8091C000826032 +:10EA10008093C00080E18093C40088E18093C100AE +:10EA20000000EE24FF24870184E0A82EB12CCC2422 +:10EA3000DD2424C0C5010197F1F70894E11CF11C05 +:10EA4000011D111D21E9E2162FE5F20621E0020762 +:10EA500020E0120718F0B1E0CB2ED12CC801B7018D +:10EA600027EC3BE140E050E00F94A8FF61157105F1 +:10EA70008105910519F485B1805885B98091C00050 +:10EA800087FD03C0C114D104A9F2A6014F5F5F4FF7 +:10EA9000C25EDE4F59834883CE51D140C25EDE4F05 +:10EAA00068817981CE51D1406130710511F00D94AA +:10EAB00077FFCE5CDE4F19821882C253D14060E0EE +:10EAC000CF5CDE4F1882C153D140AA24BB24C15D64 +:10EAD000DE4F19821882CF52D140C05EDE4F1882BD +:10EAE00019821A821B82C052D140CC5CDE4F188240 +:10EAF00019821A821B82C453D14080E090E0A0E0CA +:10EB0000B0E0ABBFFC01A791B691C25CDE4FB98308 +:10EB1000A883CE53D1400D9472FFC25EDE4FE881D0 +:10EB2000F981CE51D140319709F52091C600C25EDE +:10EB3000DE4F19821882CE51D14022C02F5F3F4F45 +:10EB40004F4F5F4F2130F2E13F07FAE74F07F0E008 +:10EB50005F0780F0C25CDE4F08811981CE53D1403F +:10EB60000F5F1F4F19F0EE27FF27099420E030E0D8 +:10EB700040E050E08091C00087FFE0CF2091C600C8 +:10EB8000C15DDE4F48815981CF52D1404F5F5F4F09 +:10EB9000C15DDE4F59834883CF52D140213209F005 +:10EBA0009CC64A30510508F098C60894A11CB11CB7 +:10EBB00053E0A516B10409F092C600E010E018C0B9 +:10EBC00061E26093C6008091C00086FFFCCF809117 +:10EBD000C00080648093C0002F5F3F4F2931310512 +:10EBE00079F70F9436F30F5F1F4F0530110519F0B9 +:10EBF00020E030E0E5CF1092080210920902109256 +:10EC00000A0210920B021092040210920502109256 +:10EC10000602109207021092000210920102109256 +:10EC20000202109203028FEE90EE60E00F944FF319 +:10EC300080E191EE60E00F9418F38091C00087FFAF +:10EC4000FCCF9091C600903608F09F759032B8F0D6 +:10EC50009093C6008091C00086FFFCCF8091C000D9 +:10EC600080648093C00080E28093C6008091C000E1 +:10EC700086FFFCCF8091C00080648093C0009834F0 +:10EC800009F4DBC19934B8F4923409F45DC19334CA +:10EC900058F4903319F1903308F41CC69F33A1F156 +:10ECA000903409F017C6BDC0953409F474C1963488 +:10ECB00009F010C69CC1923509F42FC2933538F47F +:10ECC0009C3409F4F9C1913509F004C61CC296358B +:10ECD00009F449C2993509F0FDC5A0C483E792EE55 +:10ECE00062E00F944FF3109204021092050210920A +:10ECF0000602109207021092080210920902109266 +:10ED00000A0210920B0217C18FE792EE62E00F9495 +:10ED10004FF38FEE90EE60E00F944FF381E291EEAF +:10ED200060E00F9418F387EB91EE60E00F944FF3DF +:10ED300080E391EE60E00F9418F384EE90EE60E0D3 +:10ED40000F944FF38FE391EE60E00F9418F386E099 +:10ED500090E061E070E00F948EF30F9436F38DE550 +:10ED600091EE60E00F9418F389EC91EE60E00F945F +:10ED70004FF38EE491EE60E00F9418F383EC91EE84 +:10ED800060E00F944FF38CE691EE60E00F9418F37F +:10ED90008EE10F9467F388E90F9467F381E00F9495 +:10EDA00067F30F9436F38BE791EE60E00F9418F35E +:10EDB00019E0E0E0F0E010935700E4918E2F0F94FB +:10EDC00067F30F9436F38AE891EE60E00F9418F33E +:10EDD000E3E0F0E010935700E4918E2F0F9467F377 +:10EDE0000F9436F389E991EE60E00F9418F3E2E0B6 +:10EDF000F0E010935700E4918E2F0F9467F30F9477 +:10EE000036F388EA91EE60E00F9418F3E1E0F0E069 +:10EE1000109357001491812F0F9467F30F9436F3DA +:10EE200007CF8BE892EE62E00F944FF38BE492EE03 +:10EE300060E00F944FF30F9436F300E010E019C038 +:10EE4000C8016F2D0F94E6FFFF2031F489E492EEA4 +:10EE500060E00F9418F30BC0F092C6008091C000E0 +:10EE600086FFFCCF8091C00080648093C0000F5F5C +:10EE70001F4FC80181519F41AA2797FDA095BA2F26 +:10EE8000ABBFFC01F7907AE2F71621F082E0003088 +:10EE90001807B1F60F9436F30F9436F387E592EE28 +:10EEA00060E00F944FF30F9436F300E010E0CC24B1 +:10EEB000DD241EC0C8010F94DEFFF82E882331F434 +:10EEC00089E492EE60E00F9418F30BC08093C600C3 +:10EED0008091C00086FFFCCF8091C0008064809349 +:10EEE000C000FE1419F00894C11CD11C0F5F1F4F05 +:10EEF000C80181519F41AA2797FDA095BA2FABBFAA +:10EF0000FC01E7909AE2E91621F0A2E000301A072E +:10EF100089F60F9436F30F9436F382E692EE60E0B2 +:10EF20000F9418F3C60161E070E00F948EF30F9414 +:10EF300036F30F9436F310920002109201021092F1 +:10EF400002021092030274CE89E992EE62E00F94FD +:10EF50004FF3279A2F9A16C02F9880E090E0E0EDAB +:10EF6000F7E03197F1F7019684369105C1F72F9AB2 +:10EF700080E090E0E0EDF7E03197F1F7019684361C +:10EF80009105C1F78091C00087FFE6CF8091C00056 +:10EF900087FFFCCF99C485EA92EE62E00F944FF3AD +:10EFA00040910002509101026091020270910302AF +:10EFB00081E020E10F9415F480910002909101020C +:10EFC000A0910202B091030280509F4FAF4FBF4FFC +:10EFD0008093000290930102A0930202B093030277 +:10EFE00080509041A040B04008F422CEA4CF83EBE3 +:10EFF00092EE62E00F944FF34091040250910502AB +:10F00000609106027091070280E020E10F9415F4F0 +:10F010008091040290910502A0910602B09107022E +:10F0200080509F4FAF4FBF4F8093040290930502D3 +:10F03000A0930602B0930702FBCD80EC92EE62E053 +:10F040000F944FF383E792EE60E00F944FF38FE756 +:10F0500092EE60E00F944FF38BE892EE60E00F9435 +:10F060004FF389E992EE60E00F944FF385EA92EE58 +:10F0700060E00F944FF383EB92EE60E00F944FF358 +:10F0800080EC92EE60E00F944FF387EC92EE60E03C +:10F090000F944FF388ED92EE60E00F944FF38FEDF5 +:10F0A00092EE60E00F944FF38AEE92EE60E00F94E0 +:10F0B0004FF383E093EEB9CD87EC92EE62E00F94CC +:10F0C0004FF381E40F94FFF382E40F94FFF383E4A2 +:10F0D0000F94FFF384E40F94FFF385E40F94FFF3A0 +:10F0E00086E40F94FFF387E40F94FFF388E40F9412 +:10F0F000FFF38AE40F94FFF38BE40F94FFF38CE4A7 +:10F100000F94FFF395CD88ED92EE62E00F944FF3EC +:10F1100099249394AA24BB2449C48FED92EE62E013 +:10F120000F944FF3409108025091090260910A0236 +:10F1300070910B0282E020E10F9415F48091080297 +:10F1400090910902A0910A02B0910B0280509F4F4A +:10F15000AF4FBF4F8093080290930902A0930A0219 +:10F16000B0930B0265CD8AEE92EE62E00F944FF3FE +:10F1700084EE90EE60E00F944FF38FEC91EE60E040 +:10F180000F944FF30CE415EECC5DDE4F198308832A +:10F19000C452D140662477244301CA5DDE4F1982F0 +:10F1A0001882C652D140A4019301569547953795D0 +:10F1B0002795C85DDE4F288339834A835B83C85215 +:10F1C000D140CA5DDE4F48815981C652D1404F5F60 +:10F1D0005F4FCA5DDE4F59834883C652D140CA0192 +:10F1E00062E070E00F948EF350E25093C60080917D +:10F1F000C00086FFFCCF8091C00080648093C00077 +:10F200006DE26093C6008091C00086FFFCCF8091C4 +:10F21000C00080648093C00070E27093C60080914B +:10F22000C00086FFFCCF8091C00080648093C00046 +:10F23000C85DDE4FE880F9800A811B81C852D14049 +:10F24000BB27A12F902F8F2D0F9467F3C85DDE4F42 +:10F250008881C852D1400F9467F3E0E2FE2EF0920D +:10F26000C6008091C00086FFFCCF8091C000806402 +:10F270008093C0000DE30093C6008091C00086FF1C +:10F28000FCCF8091C00080648093C00010E2109396 +:10F29000C6008091C00086FFFCCF8091C0008064D2 +:10F2A0008093C0008BBEF3012791C45DDE4F28839D +:10F2B000CC52D140A22EBB24CC24DD240894611C66 +:10F2C000711C811C911C8BBEF3018791282E332465 +:10F2D000442455240894611C711C811C911C8BBE14 +:10F2E000F3013791C35DDE4F3883CD52D14008948E +:10F2F000611C711C811C911C8BBEF3014791C25D86 +:10F30000DE4F4883CE52D1407DEFE72E7FEFF72EC0 +:10F310007FEF072F7FEF172F6E0C7F1C801E911E33 +:10F32000142D032DF22CEE24EA0CFB1C0C1D1D1DCC +:10F330000F9467F320E22093C6008091C00086FFFF +:10F34000FCCF8091C00080648093C000C45DDE4F1C +:10F350008881CC52D1400F9467F330E23093C600DD +:10F360008091C00086FFFCCF8091C00080648093B4 +:10F37000C000C25DDE4F8881CE52D1400F9467F34A +:10F3800040E24093C6008091C00086FFFCCF809190 +:10F39000C00080648093C000C35DDE4F8881CD5281 +:10F3A000D1400F9467F350E25093C6008091C000A3 +:10F3B00086FFFCCF8091C00080648093C0006FEF17 +:10F3C000E6166FEFF60660E0060760E0160731F418 +:10F3D00084E092EE60E00F9418F3DFC0D801C7011B +:10F3E0008070907CA070B0708050904CA040B04075 +:10F3F000D1F58FEF9FE3A0E0B0E0E822F9220A23E5 +:10F400001B23C85DDE4FA880B980CA80DB80C8524C +:10F41000D140AE0CBF1CC01ED11EAA0CBB1CCC1C04 +:10F42000DD1C8EE092EE60E00F9418F3BB27A12F55 +:10F43000902F8F2D0F9467F38E2D0F9467F390E22A +:10F440009093C6008091C00086FFFCCF8091C000E1 +:10F4500080648093C000AEE3A093C6008091C0009A +:10F4600086FFFCCF87C02EE03EEF40E050E0E22276 +:10F47000F322042315233CE0E31634E9F30630E0DD +:10F48000030730E0130709F088C0C25DDE4F4881F2 +:10F49000CE52D140E42EFF2400E010E0102F0F2DBB +:10F4A000FE2CEE24C35DDE4F5881CD52D140E50ED7 +:10F4B000F11C011D111DD601C50181709070A07055 +:10F4C000B070DC0199278827E80EF91E0A1F1B1F60 +:10F4D00060EF70E080E090E0A622B722C822D92237 +:10F4E000F1E1AA0CBB1CCC1CDD1CFA95D1F7EA0C8F +:10F4F000FB1C0C1D1D1D81E090E0A0E0B0E0282267 +:10F5000039224A225B22E5E1220C331C441C551CA3 +:10F51000EA95D1F7E20CF31C041D151D5701680193 +:10F52000AA0CBB1CCC1CDD1C85E192EE60E00F94A4 +:10F5300018F3C801AA27BB270F9467F3BB27A12F95 +:10F54000902F8F2D0F9467F38E2D0F9467F390E219 +:10F550009093C6008091C00086FFFCCF8091C000D0 +:10F5600080648093C000AEE3A093C6008091C00089 +:10F5700086FFFCCF8091C00080648093C000C601EC +:10F58000AA27BB270F9467F3BB27AD2D9C2D8B2D8E +:10F590000F9467F38A2D0F9467F3B0E2B093C6001F +:10F5A0008091C00086FFFCCF8091C0008064809372 +:10F5B000C000CC5DDE4FE881F981C452D140CF015B +:10F5C000AA2797FDA095BA2FABBFFC018791969112 +:10F5D00060E00F9418F30F9436F3CC5DDE4F088192 +:10F5E0001981C452D1400E5F1F4FCC5DDE4F19838D +:10F5F0000883C452D140CA5DDE4F28813981C6528A +:10F60000D1402933310509F413CB44E050E060E0E8 +:10F6100070E0640E751E861E971EC5CD83E093EEC6 +:10F6200062E00F944FF38AE192EE60E00F9418F3DA +:10F630008091C00087FFFCCF1091C6001F7510930A +:10F64000C6008091C00086FFFCCF8091C00080641E +:10F650008093C0000F9436F3812F81548A3108F0D3 +:10F6600036C1163409F495C0173490F4133409F4F4 +:10F670004EC0143430F41134F1F0123409F01DC1CD +:10F6800030C0143409F459C0153409F016C16BC0E8 +:10F690001A3409F4C4C01B3438F4173409F48FC089 +:10F6A000183409F00AC1A1C01B3409F4D2C01C34BB +:10F6B00009F003C1E8C08FEF81B90DC082B1809518 +:10F6C00082B980E090E0E0EDF7E03197F1F7019644 +:10F6D000883C9105C1F78091C00087FFEFCF12B839 +:10F6E000EFC08FEF84B90DC085B1809585B980E0FA +:10F6F00090E0E0EDF7E03197F1F70196883C910555 +:10F70000C1F78091C00087FFEFCF15B8D9C08FEF48 +:10F7100087B90DC088B1809588B980E090E0E0EDB0 +:10F72000F7E03197F1F70196883C9105C1F7809198 +:10F73000C00087FFEFCF18B8C3C08FEF8AB90DC0E4 +:10F740008BB180958BB980E090E0E0EDF7E03197E8 +:10F75000F1F70196883C9105C1F78091C00087FFC1 +:10F76000EFCF1BB8ADC08FEF8DB90DC08EB18095B6 +:10F770008EB980E090E0E0EDF7E03197F1F7019687 +:10F78000883C9105C1F78091C00087FFEFCF1EB87C +:10F7900097C08FEF80BB0DC081B3809581BB80E0A7 +:10F7A00090E0E0EDF7E03197F1F70196883C9105A4 +:10F7B000C1F78091C00087FFEFCF11BA81C08FEFF2 +:10F7C00083BB0DC084B3809584BB80E090E0E0ED06 +:10F7D000F7E03197F1F70196883C9105C1F78091E8 +:10F7E000C00087FFEFCF14BA6BC08FEF8093010189 +:10F7F0000FC08091020180958093020180E090E02B +:10F80000E0EDF7E03197F1F70196883C9105C1F7FB +:10F810008091C00087FFEDCF1092020151C08FEFA1 +:10F82000809304010FC080910501809580930501AC +:10F8300080E090E0E0EDF7E03197F1F70196883C49 +:10F840009105C1F78091C00087FFEDCF10920501AF +:10F8500037C08FEF809307010FC08091080180951A +:10F860008093080180E090E0E0EDF7E03197F1F758 +:10F870000196883C9105C1F78091C00087FFEDCFCC +:10F88000109208011DC08FEF80930A010FC0809174 +:10F890000B01809580930B0180E090E0E0EDF7E0B4 +:10F8A0003197F1F70196883C9105C1F78091C0002E +:10F8B00087FFEDCF10920B0103C085E292EEB5C930 +:10F8C0008091C00087FFFCCF8091C600B1C988E35A +:10F8D00092EEABC98CE191EEA8C9AA24BB24933067 +:10F8E00061F1943028F4913089F0923008F508C025 +:10F8F0009530B1F1953040F1963009F053C04EC0CB +:10F900002B3109F00AC991E06BE107C9213041F0C0 +:10F91000CF5CDE4F5881C153D140251709F002C397 +:10F920006227CF5CDE4F2883C153D14092E0F5C8F7 +:10F93000B22FA0E0622793E0F0C8822F90E0A82BBE +:10F94000B92B622794E0E9C82E3009F0EBC2622798 +:10F9500095E0CE5CDE4F19821882C253D140DDC8DB +:10F96000E1E0F0E0EC0FFD1FCE5CDE4FE880F980B7 +:10F97000C253D140EE0DFF1D208387010F5F1F4F43 +:10F98000CE5CDE4F19830883C253D14062270A1729 +:10F990001B0709F0C2C8D80196E0BFC8261709F0B6 +:10F9A000C1C203C0973009F0B8C899248981833156 +:10F9B00009F4FCC08431C8F4863009F4C2C0873031 +:10F9C00050F4823009F4F0C0833009F458C081301B +:10F9D00009F00AC23EC0813109F462C0823108F0E8 +:10F9E000A6C0803109F000C2DFC0883109F472C0BE +:10F9F000893150F4853109F4D9C0853108F477C1D3 +:10FA0000863109F0F1C173C18A3109F457C08A31D6 +:10FA100008F47CC08B3109F446C08D3109F0E4C193 +:10FA20008D81803311F090E00AC08F81882311F41A +:10FA30009EE105C0813011F091E001C098E91A8281 +:10FA40001B828D818C831D829E831F8227E030E084 +:10FA5000CFC11A8288E08B8381E48C8386E58D8315 +:10FA600082E58E8389E48F8383E5888780E58987B3 +:10FA70008FE58A8782E38B872BE030E0B9C18A81EA +:10FA8000813941F0823941F0803911F48FE005C0AD +:10FA900080E003C082E001C08AE01A828B8344C008 +:10FAA0009924939481C08D81882311F48EE12CC018 +:10FAB000813011F081E028C088E926C01A82E1E097 +:10FAC000F0E089E08093570084918B831C8224E0CE +:10FAD00030E08EC18B81803589F48C81883039F497 +:10FAE000E2E0F0E089E08093570084910DC0E0E00F +:10FAF000F0E089E080935700849106C0E3E0F0E0F5 +:10FB000089E08093570084911A82DFCF8D81836CC6 +:10FB100099E0E1E0F0E0082E90935700E89507B6F1 +:10FB200000FCFDCF1A821B8223E030E061C11A8203 +:10FB3000CC5CDE4F188219821A821B82C453D140DA +:10FB400055C18A8190E0A0E0B0E0582F44273327C8 +:10FB500022278B8190E0A0E0B0E0DC019927882784 +:10FB6000282B392B4A2B5B2B8D8190E0A0E0B0E055 +:10FB7000282B392B4A2B5B2B8C8190E0A0E0B0E046 +:10FB8000BA2FA92F982F8827282B392B4A2B5B2B8C +:10FB9000220F331F441F551FC05EDE4F2883398359 +:10FBA0004A835B83C052D1401A8220C19A812B8143 +:10FBB000833149F0C05EDE4F488159816A817B8183 +:10FBC000C052D1408AC0CC5CDE4F488159816A81E5 +:10FBD0007B81C453D140403080EC580783E06807F4 +:10FBE00080E07807F0F483E0FA0160935B00809393 +:10FBF0005700E89507B600FCFDCFCC5CDE4F48818E +:10FC000059816A817B81C453D14040505F4F6F4F0F +:10FC10007F4FCC5CDE4F488359836A837B83C45318 +:10FC2000D140C75CDE4F9883C953D140C85CDE4FDA +:10FC30001882C853D140022F10E0C85CDE4F6881A3 +:10FC40007981C853D140062B172BC05EDE4F488107 +:10FC500059816A817B81C052D140DE011B9631E01F +:10FC60008C9111962C9111971296C55CDE4F2883CA +:10FC7000CB53D140C65CDE4F1882CA53D14090E0CE +:10FC8000C65CDE4FE881F981CA53D1408E2B9F2B91 +:10FC90000C01FA0160935B0030935700E895112442 +:10FCA0004E5F5F4F6F4F7F4F02501040C9F685E0A7 +:10FCB000C05EDE4FE880F9800A811B81C052D140CE +:10FCC000F70100935B0080935700E89507B600FCAE +:10FCD000FDCF81E180935700E8951A82C05EDE4F28 +:10FCE000488359836A837B83C052D1407FC0FA80A6 +:10FCF000C35CDE4FF882CD53D140C45CDE4F188226 +:10FD0000CC53D1408B81C82EDD24C45CDE4F0881EA +:10FD10001981CC53D140C02AD12A1A828981BE01CF +:10FD20006D5F7F4F843121F59601C05EDE4FE88024 +:10FD3000F9800A811B81C052D1400BBFF701879126 +:10FD40009691DB018C9311969C936E5F7F4FD80147 +:10FD5000C7010296A11DB11DC05EDE4F8883998345 +:10FD6000AA83BB83C052D14022503040F1F636C046 +:10FD7000C05EDE4F288139814A815B81C052D1400B +:10FD80000894C108D108760100E010E00894C11C75 +:10FD9000D11C0894E11CF11C011D111DE20EF31E83 +:10FDA000041F151F21BDBB27A52F942F832F82BDB4 +:10FDB0002F5F3F4F4F4F5F4FF89A80B5DB018D9318 +:10FDC000BD012E153F054007510761F7C05EDE4FAC +:10FDD000288339834A835B83C052D14096012D5FCB +:10FDE0003F4FFB01108204C080EC8A8322E030E0A8 +:10FDF0008BE18093C6008091C00086FFFCCF80918C +:10FE0000C00080648093C000CF5CDE4FF881C15396 +:10FE1000D140F093C6008091C00086FFFCCF809156 +:10FE2000C00080648093C000432F3093C60080914F +:10FE3000C00086FFFCCF8091C00080648093C0002A +:10FE4000922F2093C6008091C00086FFFCCF809146 +:10FE5000C00080648093C0008EE08093C6008091D3 +:10FE6000C00086FFFCCF8091C00080648093C000FA +:10FE700065E1CF5CDE4FE880C153D1406E25692734 +:10FE80006427FE01319610C090819093C600809146 +:10FE9000C00086FFFCCF31968091C00080648093C3 +:10FEA000C0006927215030402115310569F7609362 +:10FEB000C6008091C00086FFFCCF8091C0008064A6 +:10FEC0008093C00085B1805885B9992081F4CF5CBA +:10FED000DE4F0881C153D1400F5FCF5CDE4F0883F6 +:10FEE000C153D14090E0A0E0B0E00D948DF527988B +:10FEF0002F9880E090E020ED37E0F9013197F1F79D +:10FF0000019684369105C9F700008091C0008D7F6D +:10FF10008093C00081E180935700E895EE27FF278A +:10FF20000994FFCF90E00D948DF597FB092E0726DD +:10FF30000AD077FD04D02ED006D000201AF4709598 +:10FF400061957F4F0895F6F7909581959F4F08959D +:10FF5000A1E21A2EAA1BBB1BFD010DC0AA1FBB1FCD +:10FF6000EE1FFF1FA217B307E407F50720F0A21B3F +:10FF7000B30BE40BF50B661F771F881F991F1A94AC +:10FF800069F760957095809590959B01AC01BD01D6 +:10FF9000CF010895AA1BBB1B51E107C0AA1FBB1FBD +:10FFA000A617B70710F0A61BB70B881F991F5A9505 +:10FFB000A9F780959095BC01CD010895F999FECFE0 +:10FFC00092BD81BDF89A992780B50895262FF99999 +:10FFD000FECF1FBA92BD81BD20BD0FB6F894FA9A2C +:0CFFE000F99A0FBE01960895F894FFCF27 :040000033000E000E9 :00000001FF