From 6f1482babaa7d47fc791f37c7ba689d9b64b3e51 Mon Sep 17 00:00:00 2001 From: aethaniel Date: Wed, 1 Jun 2011 01:54:47 +0200 Subject: [PATCH] Adding Atmel SAM3 specific files --- hardware/atmel/boards.txt | 13 + hardware/atmel/cores/sam/Arduino.h | 155 +++++ hardware/atmel/cores/sam/HardwareSerial.cpp | 18 + hardware/atmel/cores/sam/HardwareSerial.h | 39 ++ hardware/atmel/cores/sam/Print.cpp | 218 ++++++ hardware/atmel/cores/sam/Print.h | 65 ++ hardware/atmel/cores/sam/Stream.h | 35 + hardware/atmel/cores/sam/Tone.cpp | 601 ++++++++++++++++ hardware/atmel/cores/sam/UART.cpp | 139 ++++ hardware/atmel/cores/sam/UART.h | 30 + hardware/atmel/cores/sam/USART.cpp | 73 ++ hardware/atmel/cores/sam/USART.h | 30 + hardware/atmel/cores/sam/WCharacter.h | 168 +++++ hardware/atmel/cores/sam/WInterrupts.c | 23 + hardware/atmel/cores/sam/WMath.cpp | 60 ++ hardware/atmel/cores/sam/WString.cpp | 645 ++++++++++++++++++ hardware/atmel/cores/sam/WString.h | 204 ++++++ hardware/atmel/cores/sam/binary.h | 515 ++++++++++++++ hardware/atmel/cores/sam/build_gcc/Makefile | 24 + .../cores/sam/build_gcc/arduino_sam3s_ek.mk | 146 ++++ hardware/atmel/cores/sam/build_gcc/debug.mk | 7 + .../build_gcc/debug_sam3s_ek/HardwareSerial.o | Bin 0 -> 7084 bytes .../sam/build_gcc/debug_sam3s_ek/Print.o | Bin 0 -> 39044 bytes .../cores/sam/build_gcc/debug_sam3s_ek/UART.o | Bin 0 -> 25736 bytes .../sam/build_gcc/debug_sam3s_ek/USART.o | Bin 0 -> 25512 bytes .../build_gcc/debug_sam3s_ek/WInterrupts.o | Bin 0 -> 6024 bytes .../cores/sam/build_gcc/debug_sam3s_ek/main.o | Bin 0 -> 8652 bytes .../sam/build_gcc/debug_sam3s_ek/wiring.o | Bin 0 -> 15344 bytes .../build_gcc/debug_sam3s_ek/wiring_shift.o | Bin 0 -> 9472 bytes hardware/atmel/cores/sam/build_gcc/gcc.mk | 63 ++ hardware/atmel/cores/sam/build_gcc/release.mk | 8 + .../release_sam3s_ek/HardwareSerial.o | Bin 0 -> 708 bytes .../sam/build_gcc/release_sam3s_ek/Print.o | Bin 0 -> 13216 bytes .../sam/build_gcc/release_sam3s_ek/UART.o | Bin 0 -> 7252 bytes .../sam/build_gcc/release_sam3s_ek/USART.o | Bin 0 -> 6948 bytes .../build_gcc/release_sam3s_ek/WInterrupts.o | Bin 0 -> 1176 bytes .../sam/build_gcc/release_sam3s_ek/main.o | Bin 0 -> 1296 bytes .../sam/build_gcc/release_sam3s_ek/wiring.o | Bin 0 -> 1956 bytes .../build_gcc/release_sam3s_ek/wiring_shift.o | Bin 0 -> 1288 bytes .../cores/sam/lib/arduino_sam3s_ek_gcc_dbg.a | Bin 0 -> 139626 bytes .../sam/lib/arduino_sam3s_ek_gcc_dbg.a.txt | 199 ++++++ .../cores/sam/lib/arduino_sam3s_ek_gcc_rel.a | Bin 0 -> 36314 bytes .../sam/lib/arduino_sam3s_ek_gcc_rel.a.txt | 135 ++++ hardware/atmel/cores/sam/main.cpp | 15 + .../atmel/cores/sam/sam3s_ek/pins_arduino.h | 146 ++++ .../atmel/cores/sam/sam3s_ek/sam3s-ek.cpp | 51 ++ hardware/atmel/cores/sam/sam3s_ek/sam3s-ek.h | 13 + .../cores/sam/sam3s_ek/sam3s_ek_flash.gdb | 31 + .../cores/sam/sam3s_ek/sam3s_ek_flash.ld | 140 ++++ .../cores/sam/sam3s_ek/sam3s_ek_sram.gdb | 27 + .../atmel/cores/sam/sam3s_ek/sam3s_ek_sram.ld | 140 ++++ hardware/atmel/cores/sam/validation/test.cpp | 21 + hardware/atmel/cores/sam/wiring.c | 142 ++++ hardware/atmel/cores/sam/wiring_analog.c | 259 +++++++ hardware/atmel/cores/sam/wiring_digital.c | 165 +++++ hardware/atmel/cores/sam/wiring_private.h | 43 ++ hardware/atmel/cores/sam/wiring_pulse.c | 69 ++ hardware/atmel/cores/sam/wiring_shift.c | 55 ++ hardware/atmel/programmers.txt | 18 + 59 files changed, 4948 insertions(+) create mode 100644 hardware/atmel/boards.txt create mode 100644 hardware/atmel/cores/sam/Arduino.h create mode 100644 hardware/atmel/cores/sam/HardwareSerial.cpp create mode 100644 hardware/atmel/cores/sam/HardwareSerial.h create mode 100644 hardware/atmel/cores/sam/Print.cpp create mode 100644 hardware/atmel/cores/sam/Print.h create mode 100644 hardware/atmel/cores/sam/Stream.h create mode 100644 hardware/atmel/cores/sam/Tone.cpp create mode 100644 hardware/atmel/cores/sam/UART.cpp create mode 100644 hardware/atmel/cores/sam/UART.h create mode 100644 hardware/atmel/cores/sam/USART.cpp create mode 100644 hardware/atmel/cores/sam/USART.h create mode 100644 hardware/atmel/cores/sam/WCharacter.h create mode 100644 hardware/atmel/cores/sam/WInterrupts.c create mode 100644 hardware/atmel/cores/sam/WMath.cpp create mode 100644 hardware/atmel/cores/sam/WString.cpp create mode 100644 hardware/atmel/cores/sam/WString.h create mode 100644 hardware/atmel/cores/sam/binary.h create mode 100644 hardware/atmel/cores/sam/build_gcc/Makefile create mode 100644 hardware/atmel/cores/sam/build_gcc/arduino_sam3s_ek.mk create mode 100644 hardware/atmel/cores/sam/build_gcc/debug.mk create mode 100644 hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/HardwareSerial.o create mode 100644 hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/Print.o create mode 100644 hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/UART.o create mode 100644 hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/USART.o create mode 100644 hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/WInterrupts.o create mode 100644 hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/main.o create mode 100644 hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/wiring.o create mode 100644 hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/wiring_shift.o create mode 100644 hardware/atmel/cores/sam/build_gcc/gcc.mk create mode 100644 hardware/atmel/cores/sam/build_gcc/release.mk create mode 100644 hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/HardwareSerial.o create mode 100644 hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/Print.o create mode 100644 hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/UART.o create mode 100644 hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/USART.o create mode 100644 hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/WInterrupts.o create mode 100644 hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/main.o create mode 100644 hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/wiring.o create mode 100644 hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/wiring_shift.o create mode 100644 hardware/atmel/cores/sam/lib/arduino_sam3s_ek_gcc_dbg.a create mode 100644 hardware/atmel/cores/sam/lib/arduino_sam3s_ek_gcc_dbg.a.txt create mode 100644 hardware/atmel/cores/sam/lib/arduino_sam3s_ek_gcc_rel.a create mode 100644 hardware/atmel/cores/sam/lib/arduino_sam3s_ek_gcc_rel.a.txt create mode 100644 hardware/atmel/cores/sam/main.cpp create mode 100644 hardware/atmel/cores/sam/sam3s_ek/pins_arduino.h create mode 100644 hardware/atmel/cores/sam/sam3s_ek/sam3s-ek.cpp create mode 100644 hardware/atmel/cores/sam/sam3s_ek/sam3s-ek.h create mode 100644 hardware/atmel/cores/sam/sam3s_ek/sam3s_ek_flash.gdb create mode 100644 hardware/atmel/cores/sam/sam3s_ek/sam3s_ek_flash.ld create mode 100644 hardware/atmel/cores/sam/sam3s_ek/sam3s_ek_sram.gdb create mode 100644 hardware/atmel/cores/sam/sam3s_ek/sam3s_ek_sram.ld create mode 100644 hardware/atmel/cores/sam/validation/test.cpp create mode 100644 hardware/atmel/cores/sam/wiring.c create mode 100644 hardware/atmel/cores/sam/wiring_analog.c create mode 100644 hardware/atmel/cores/sam/wiring_digital.c create mode 100644 hardware/atmel/cores/sam/wiring_private.h create mode 100644 hardware/atmel/cores/sam/wiring_pulse.c create mode 100644 hardware/atmel/cores/sam/wiring_shift.c create mode 100644 hardware/atmel/programmers.txt diff --git a/hardware/atmel/boards.txt b/hardware/atmel/boards.txt new file mode 100644 index 000000000..fe4dd5b83 --- /dev/null +++ b/hardware/atmel/boards.txt @@ -0,0 +1,13 @@ +############################################################## + +sam3s_ek.name=Atmel SAM3S-EK +sam3s_ek.upload.protocol=sam-ba +sam3s_ek.upload.maximum_size=49152 +sam3s_ek.upload.speed=115200 +sam3s_ek.bootloader.path=sam3s_boot +sam3s_ek.bootloader.file=sam3s_boot.bin +sam3s_ek.build.mcu=sam3s4c +sam3s_ek.build.f_cpu=64000000L +sam3s_ek.build.core=at91 + + diff --git a/hardware/atmel/cores/sam/Arduino.h b/hardware/atmel/cores/sam/Arduino.h new file mode 100644 index 000000000..929d25a30 --- /dev/null +++ b/hardware/atmel/cores/sam/Arduino.h @@ -0,0 +1,155 @@ +#ifndef Arduino_h +#define Arduino_h + +#include +#include +#include + +//! Include SAM3S-EK BSP headers +#include "board.h" + +#include "binary.h" + +#ifdef __cplusplus +extern "C"{ +#endif + +#define HIGH 0x1 +#define LOW 0x0 + +#define INPUT 0x0 +#define OUTPUT 0x1 + +#define true 0x1 +#define false 0x0 + +#define PI 3.1415926535897932384626433832795 +#define HALF_PI 1.5707963267948966192313216916398 +#define TWO_PI 6.283185307179586476925286766559 +#define DEG_TO_RAD 0.017453292519943295769236907684886 +#define RAD_TO_DEG 57.295779513082320876798154814105 + +#define SERIAL 0x0 +#define DISPLAY 0x1 + +#define LSBFIRST 0 +#define MSBFIRST 1 + +#define CHANGE 1 +#define FALLING 2 +#define RISING 3 + +#define DEFAULT 1 +#define EXTERNAL 0 + +// undefine stdlib's abs if encountered +#ifdef abs +#undef abs +#endif + +#define min(a,b) ((a)<(b)?(a):(b)) +#define max(a,b) ((a)>(b)?(a):(b)) +#define abs(x) ((x)>0?(x):-(x)) +#define constrain(amt,low,high) ((amt)<(low)?(low):((amt)>(high)?(high):(amt))) +#define round(x) ((x)>=0?(long)((x)+0.5):(long)((x)-0.5)) +#define radians(deg) ((deg)*DEG_TO_RAD) +#define degrees(rad) ((rad)*RAD_TO_DEG) +#define sq(x) ((x)*(x)) + +#define interrupts() sei() +#define noInterrupts() cli() + +#define clockCyclesPerMicrosecond() ( BOARD_MCK / 1000000L ) +#define clockCyclesToMicroseconds(a) ( ((a) * 1000L) / (BOARD_MCK / 1000L) ) +#define microsecondsToClockCycles(a) ( ((a) * (BOARD_MCK / 1000L)) / 1000L ) + +#define lowByte(w) ((uint8_t) ((w) & 0xff)) +#define highByte(w) ((uint8_t) ((w) >> 8)) + +#define bitRead(value, bit) (((value) >> (bit)) & 0x01) +#define bitSet(value, bit) ((value) |= (1UL << (bit))) +#define bitClear(value, bit) ((value) &= ~(1UL << (bit))) +#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit)) + + +typedef unsigned int word; + +#define bit(b) (1UL << (b)) + +typedef uint8_t boolean; +typedef uint8_t byte; + +void init(void); + +void pinMode(uint8_t, uint8_t); +void digitalWrite(uint8_t, uint8_t); +int digitalRead(uint8_t); +int analogRead(uint8_t); +void analogReference(uint8_t mode); +void analogWrite(uint8_t, int); + +unsigned long millis(void); +unsigned long micros(void); +//void delay(unsigned long); +#define delay( dwMs ) Wait( dwMs ) +void delayMicroseconds(unsigned int us); + +void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val); +uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder); + +void attachInterrupt(uint8_t, void (*)(void), int mode); +void detachInterrupt(uint8_t); + +void setup(void); +void loop(void); + +// Get the bit location within the hardware port of the given virtual pin. +// This comes from the pins_*.c file for the active board configuration. +// +// These perform slightly better as macros compared to inline functions +// +#define digitalPinToPort( Pin ) ( APinDescription[Pin]->pPort ) +#define digitalPinToBitMask( Pin ) ( APinDescription[Pin]->dwPin ) +#define digitalPinToTimer( P ) ( ) +#define analogInPinToBit( P ) ( P ) +#define portOutputRegister( P ) ( ) +#define portInputRegister( P ) ( ) +#define portModeRegister( P ) ( ) + +//#define NOT_A_PIN 0 // defined in pio.h/EPioType +#define NOT_A_PORT 0 + +#define NOT_ON_TIMER 0 +#define TIMER0 1 + + +#ifdef __cplusplus +} // extern "C" +#endif + +#ifdef __cplusplus +#include "WCharacter.h" +#include "WString.h" +#include "HardwareSerial.h" + +uint16_t makeWord(uint16_t w); +uint16_t makeWord(byte h, byte l); + +#define word(...) makeWord(__VA_ARGS__) + +unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout = 1000000L); + +void tone(uint8_t _pin, unsigned int frequency, unsigned long duration = 0); +void noTone(uint8_t _pin); + +// WMath prototypes +long random(long); +long random(long, long); +void randomSeed(unsigned int); +long map(long, long, long, long, long); + +#endif + +#include "pins_arduino.h" + +#endif \ No newline at end of file diff --git a/hardware/atmel/cores/sam/HardwareSerial.cpp b/hardware/atmel/cores/sam/HardwareSerial.cpp new file mode 100644 index 000000000..27d052e0f --- /dev/null +++ b/hardware/atmel/cores/sam/HardwareSerial.cpp @@ -0,0 +1,18 @@ +#include "wiring_private.h" + +#include "HardwareSerial.h" + +inline void store_char( uint8_t c, ring_buffer *pBuffer ) +{ + int i = (unsigned int)(pBuffer->head + 1) % SERIAL_BUFFER_SIZE; + + // if we should be storing the received character into the location + // just before the tail (meaning that the head would advance to the + // current location of the tail), we're about to overflow the buffer + // and so we don't write the character or advance the head. + if ( i != pBuffer->tail ) + { + pBuffer->buffer[pBuffer->head] = c ; + pBuffer->head = i ; + } +} diff --git a/hardware/atmel/cores/sam/HardwareSerial.h b/hardware/atmel/cores/sam/HardwareSerial.h new file mode 100644 index 000000000..79e0ceb39 --- /dev/null +++ b/hardware/atmel/cores/sam/HardwareSerial.h @@ -0,0 +1,39 @@ +#ifndef HardwareSerial_h +#define HardwareSerial_h + +#include + +#include "Stream.h" + +// Define constants and variables for buffering incoming serial data. We're +// using a ring buffer (I think), in which head is the index of the location +// to which to write the next incoming character and tail is the index of the +// location from which to read. +#define SERIAL_BUFFER_SIZE 64 + +typedef struct _ring_buffer +{ + uint8_t buffer[SERIAL_BUFFER_SIZE] ; + volatile int head ; + volatile int tail ; +} ring_buffer ; + +class HardwareSerial : public Stream +{ + protected: + ring_buffer *_rx_buffer ; + ring_buffer *_tx_buffer ; + + public: + virtual void begin( const uint32_t dwBaudRate ) =0 ; + virtual void end( void ) =0 ; + virtual int available( void ) =0 ; + virtual int peek( void ) =0 ; + virtual int read( void ) =0 ; + virtual void flush( void ) =0 ; + virtual void write( const uint8_t c ) =0 ; + + using Print::write ; // pull in write(str) and write(buf, size) from Print +}; + +#endif // HardwareSerial_h diff --git a/hardware/atmel/cores/sam/Print.cpp b/hardware/atmel/cores/sam/Print.cpp new file mode 100644 index 000000000..9fab9fc15 --- /dev/null +++ b/hardware/atmel/cores/sam/Print.cpp @@ -0,0 +1,218 @@ +/* + Print.cpp - Base class that provides print() and println() + Copyright (c) 2008 David A. Mellis. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Modified 23 November 2006 by David A. Mellis + */ + +#include +#include +#include +#include +#include "Arduino.h" + +#include "Print.h" + +// Public Methods ////////////////////////////////////////////////////////////// + +/* default implementation: may be overridden */ +void Print::write(const char *str) +{ + while (*str) + write(*str++); +} + +/* default implementation: may be overridden */ +void Print::write(const uint8_t *buffer, size_t size) +{ + while (size--) + write(*buffer++); +} + +void Print::print(const String &s) +{ + for (int i = 0; i < s.length(); i++) { + write(s[i]); + } +} + +void Print::print(const char str[]) +{ + write(str); +} + +void Print::print(char c) +{ + write(c); +} + +void Print::print(unsigned char b, int base) +{ + print((unsigned long) b, base); +} + +void Print::print(int n, int base) +{ + print((long) n, base); +} + +void Print::print(unsigned int n, int base) +{ + print((unsigned long) n, base); +} + +void Print::print(long n, int base) +{ + if (base == 0) { + write(n); + } else if (base == 10) { + if (n < 0) { + print('-'); + n = -n; + } + printNumber(n, 10); + } else { + printNumber(n, base); + } +} + +void Print::print(unsigned long n, int base) +{ + if (base == 0) write(n); + else printNumber(n, base); +} + +void Print::print(double n, int digits) +{ + printFloat(n, digits); +} + +void Print::println(void) +{ + print('\r'); + print('\n'); +} + +void Print::println(const String &s) +{ + print(s); + println(); +} + +void Print::println(const char c[]) +{ + print(c); + println(); +} + +void Print::println(char c) +{ + print(c); + println(); +} + +void Print::println(unsigned char b, int base) +{ + print(b, base); + println(); +} + +void Print::println(int n, int base) +{ + print(n, base); + println(); +} + +void Print::println(unsigned int n, int base) +{ + print(n, base); + println(); +} + +void Print::println(long n, int base) +{ + print(n, base); + println(); +} + +void Print::println(unsigned long n, int base) +{ + print(n, base); + println(); +} + +void Print::println(double n, int digits) +{ + print(n, digits); + println(); +} + +// Private Methods ///////////////////////////////////////////////////////////// + +void Print::printNumber(unsigned long n, uint8_t base) { + char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte. + char *str = &buf[sizeof(buf) - 1]; + + *str = '\0'; + + // prevent crash if called with base == 1 + if (base < 2) base = 10; + + do { + unsigned long m = n; + n /= base; + char c = m - base * n; + *--str = c < 10 ? c + '0' : c + 'A' - 10; + } while(n); + + write(str); +} + +void Print::printFloat(double number, uint8_t digits) +{ + // Handle negative numbers + if (number < 0.0) + { + print('-'); + number = -number; + } + + // Round correctly so that print(1.999, 2) prints as "2.00" + double rounding = 0.5; + for (uint8_t i=0; i 0) + print("."); + + // Extract digits from the remainder one at a time + while (digits-- > 0) + { + remainder *= 10.0; + int toPrint = int(remainder); + print(toPrint); + remainder -= toPrint; + } +} diff --git a/hardware/atmel/cores/sam/Print.h b/hardware/atmel/cores/sam/Print.h new file mode 100644 index 000000000..c09063660 --- /dev/null +++ b/hardware/atmel/cores/sam/Print.h @@ -0,0 +1,65 @@ +/* + Print.h - Base class that provides print() and println() + Copyright (c) 2008 David A. Mellis. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef Print_h +#define Print_h + +#include +#include // for size_t + +#include "WString.h" + +#define DEC 10 +#define HEX 16 +#define OCT 8 +#define BIN 2 + +class Print +{ + private: + void printNumber(unsigned long, uint8_t); + void printFloat(double, uint8_t); + public: + virtual void write(uint8_t) = 0; + virtual void write(const char *str); + virtual void write(const uint8_t *buffer, size_t size); + + void print(const String &); + void print(const char[]); + void print(char); + void print(unsigned char, int = DEC); + void print(int, int = DEC); + void print(unsigned int, int = DEC); + void print(long, int = DEC); + void print(unsigned long, int = DEC); + void print(double, int = 2); + + void println(const String &s); + void println(const char[]); + void println(char); + void println(unsigned char, int = DEC); + void println(int, int = DEC); + void println(unsigned int, int = DEC); + void println(long, int = DEC); + void println(unsigned long, int = DEC); + void println(double, int = 2); + void println(void); +}; + +#endif diff --git a/hardware/atmel/cores/sam/Stream.h b/hardware/atmel/cores/sam/Stream.h new file mode 100644 index 000000000..93d8275dc --- /dev/null +++ b/hardware/atmel/cores/sam/Stream.h @@ -0,0 +1,35 @@ +/* + Stream.h - base class for character-based streams. + Copyright (c) 2010 David A. Mellis. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef Stream_h +#define Stream_h + +#include +#include "Print.h" + +class Stream : public Print +{ + public: + virtual int available() = 0; + virtual int read() = 0; + virtual int peek() = 0; + virtual void flush() = 0; +}; + +#endif diff --git a/hardware/atmel/cores/sam/Tone.cpp b/hardware/atmel/cores/sam/Tone.cpp new file mode 100644 index 000000000..20eed3f48 --- /dev/null +++ b/hardware/atmel/cores/sam/Tone.cpp @@ -0,0 +1,601 @@ +/* Tone.cpp + + A Tone Generator Library + + Written by Brett Hagman + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +Version Modified By Date Comments +------- ----------- -------- -------- +0001 B Hagman 09/08/02 Initial coding +0002 B Hagman 09/08/18 Multiple pins +0003 B Hagman 09/08/18 Moved initialization from constructor to begin() +0004 B Hagman 09/09/26 Fixed problems with ATmega8 +0005 B Hagman 09/11/23 Scanned prescalars for best fit on 8 bit timers + 09/11/25 Changed pin toggle method to XOR + 09/11/25 Fixed timer0 from being excluded +0006 D Mellis 09/12/29 Replaced objects with functions +0007 M Sproul 10/08/29 Changed #ifdefs from cpu to register +*************************************************/ + +#include +#include +#include "Arduino.h" +#include "pins_arduino.h" + +#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: +// > 0 - duration specified +// = 0 - stopped +// < 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; +#endif + +volatile long timer1_toggle_count; +volatile uint8_t *timer1_pin_port; +volatile uint8_t timer1_pin_mask; +volatile long timer2_toggle_count; +volatile uint8_t *timer2_pin_port; +volatile uint8_t timer2_pin_mask; + +#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 + + +// MLS: This does not make sense, the 3 options are the same +#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) + +#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 */ }; + +#elif defined(__AVR_ATmega8__) + +#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 */ }; + +#else + +#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 */ }; + +#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(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(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(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(TCCR0B) + if (_timer == 0) + { + TCCR0B = prescalarbits; + } + else +#endif +#if defined(TCCR2B) + { + TCCR2B = prescalarbits; + } +#else + { + // dummy 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(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(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(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) + { + 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(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; + + for (int i = 0; i < AVAILABLE_TONE_PINS; i++) { + if (tone_pins[i] == _pin) { + _timer = pgm_read_byte(tone_pin_to_timer_PGM + i); + tone_pins[i] = 255; + } + } + + disableTimer(_timer); + + digitalWrite(_pin, 0); +} + +#if 0 +#if !defined(__AVR_ATmega8__) +ISR(TIMER0_COMPA_vect) +{ + if (timer0_toggle_count != 0) + { + // toggle the pin + *timer0_pin_port ^= timer0_pin_mask; + + if (timer0_toggle_count > 0) + timer0_toggle_count--; + } + else + { + disableTimer(0); + *timer0_pin_port &= ~(timer0_pin_mask); // keep pin low after stop + } +} +#endif + + +ISR(TIMER1_COMPA_vect) +{ + if (timer1_toggle_count != 0) + { + // toggle the pin + *timer1_pin_port ^= timer1_pin_mask; + + if (timer1_toggle_count > 0) + timer1_toggle_count--; + } + else + { + disableTimer(1); + *timer1_pin_port &= ~(timer1_pin_mask); // keep pin low after stop + } +} +#endif + + +ISR(TIMER2_COMPA_vect) +{ + + if (timer2_toggle_count != 0) + { + // toggle the pin + *timer2_pin_port ^= timer2_pin_mask; + + if (timer2_toggle_count > 0) + timer2_toggle_count--; + } + else + { + // need to call noTone() so that the tone_pins[] entry is reset, so the + // timer gets initialized next time we call tone(). + // XXX: this assumes timer 2 is always the first one used. + noTone(tone_pins[0]); +// disableTimer(2); +// *timer2_pin_port &= ~(timer2_pin_mask); // keep pin low after stop + } +} + + + +//#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) +#if 0 + +ISR(TIMER3_COMPA_vect) +{ + if (timer3_toggle_count != 0) + { + // toggle the pin + *timer3_pin_port ^= timer3_pin_mask; + + if (timer3_toggle_count > 0) + timer3_toggle_count--; + } + else + { + disableTimer(3); + *timer3_pin_port &= ~(timer3_pin_mask); // keep pin low after stop + } +} + +ISR(TIMER4_COMPA_vect) +{ + if (timer4_toggle_count != 0) + { + // toggle the pin + *timer4_pin_port ^= timer4_pin_mask; + + if (timer4_toggle_count > 0) + timer4_toggle_count--; + } + else + { + disableTimer(4); + *timer4_pin_port &= ~(timer4_pin_mask); // keep pin low after stop + } +} + +ISR(TIMER5_COMPA_vect) +{ + if (timer5_toggle_count != 0) + { + // toggle the pin + *timer5_pin_port ^= timer5_pin_mask; + + if (timer5_toggle_count > 0) + timer5_toggle_count--; + } + else + { + disableTimer(5); + *timer5_pin_port &= ~(timer5_pin_mask); // keep pin low after stop + } +} + +#endif diff --git a/hardware/atmel/cores/sam/UART.cpp b/hardware/atmel/cores/sam/UART.cpp new file mode 100644 index 000000000..2d167033f --- /dev/null +++ b/hardware/atmel/cores/sam/UART.cpp @@ -0,0 +1,139 @@ +#include +#include +#include +#include "UART.h" + + +// Constructors //////////////////////////////////////////////////////////////// + +UARTClass::UARTClass( ring_buffer* rx_buffer, ring_buffer* tx_buffer, Uart* pUart, IRQn_Type dwIrq, uint32_t dwId ) +{ + _rx_buffer = rx_buffer ; + _tx_buffer = tx_buffer ; + + _pUart=pUart ; + _dwIrq=dwIrq ; + _dwId=dwId ; +} + +// Public Methods ////////////////////////////////////////////////////////////// + +void UARTClass::begin( const uint32_t dwBaudRate ) +{ + /* Configure PMC */ + PMC_EnablePeripheral( _dwId ) ; + + /* Reset and disable receiver & transmitter */ + _pUart->UART_CR = UART_CR_RSTRX | UART_CR_RSTTX | UART_CR_RXDIS | UART_CR_TXDIS ; + + /* Configure mode */ + _pUart->UART_MR = UART_MR_PAR_NO ; + + /* Configure baudrate */ + /* Asynchronous, no oversampling */ + _pUart->UART_BRGR = (BOARD_MCK / dwBaudRate) / 16 ; + + /* Disable PDC channel */ + _pUart->UART_PTCR = UART_PTCR_RXTDIS | UART_PTCR_TXTDIS ; + + /* Enable receiver and transmitter */ + _pUart->UART_CR = UART_CR_RXEN | UART_CR_TXEN ; +} + +void UARTClass::end( void ) +{ + // wait for transmission of outgoing data + while ( _tx_buffer->head != _tx_buffer->tail ) + { + } + + // clear any received data + _rx_buffer->head = _rx_buffer->tail ; + + PMC_DisablePeripheral( _dwId ) ; +} + +int UARTClass::available( void ) +{ + return (unsigned int)(SERIAL_BUFFER_SIZE + _rx_buffer->head - _rx_buffer->tail) % SERIAL_BUFFER_SIZE ; +} + +int UARTClass::peek( void ) +{ + if ( _rx_buffer->head == _rx_buffer->tail ) + { + return -1 ; + } + else + { + return _rx_buffer->buffer[_rx_buffer->tail] ; + } +} + +int UARTClass::read( void ) +{ + // if the head isn't ahead of the tail, we don't have any characters + if ( _rx_buffer->head == _rx_buffer->tail ) + { + return -1 ; + } + else + { + unsigned char c = _rx_buffer->buffer[_rx_buffer->tail] ; + + _rx_buffer->tail = (unsigned int)(_rx_buffer->tail + 1) % SERIAL_BUFFER_SIZE ; + + return c ; + } +} + +void UARTClass::flush( void ) +{ + while ( _tx_buffer->head != _tx_buffer->tail ) + { + } +} + +void UARTClass::write( const uint8_t c ) +{ + int i = (_tx_buffer->head + 1) % SERIAL_BUFFER_SIZE ; + + // If the output buffer is full, there's nothing for it other than to + // wait for the interrupt handler to empty it a bit + while ( i == _tx_buffer->tail ) + { + } + + _tx_buffer->buffer[_tx_buffer->head] = c ; + _tx_buffer->head = i ; + + /* Wait for the transmitter to be ready */ + while ( (_pUart->UART_SR & UART_SR_TXEMPTY) == 0 ) ; + + /* Send character */ + _pUart->UART_THR=c ; +} + +void UARTClass::IrqHandler( void ) +{ +/* + // RX char IT + unsigned char c = _pUart->UART_RHR ; + store_char(c, &rx_buffer3); + + // TX FIFO empty IT + if ( _tx_buffer->head == _tx_buffer->tail ) + { + // Buffer empty, so disable interrupts + } + else + { + // There is more data in the output buffer. Send the next byte + unsigned char c = _tx_buffer->buffer[_tx_buffer->tail] ; + _tx_buffer->tail = (_tx_buffer->tail + 1) % SERIAL_BUFFER_SIZE ; + + _pUart->UART_THR = c ; + } +*/ +} + diff --git a/hardware/atmel/cores/sam/UART.h b/hardware/atmel/cores/sam/UART.h new file mode 100644 index 000000000..ca736150b --- /dev/null +++ b/hardware/atmel/cores/sam/UART.h @@ -0,0 +1,30 @@ +#ifndef _UART_ +#define _UART_ + +#include +#include "wiring_private.h" + +class UARTClass : public HardwareSerial +{ + protected: + Uart* _pUart ; + IRQn_Type _dwIrq ; + uint32_t _dwId ; + + public: + UARTClass( ring_buffer *rx_buffer, ring_buffer *tx_buffer, Uart* pUart, IRQn_Type dwIrq, uint32_t dwId ) ; + + void begin( const uint32_t dwBaudRate ) ; + void end( void ) ; + int available( void ) ; + int peek( void ) ; + int read( void ) ; + void flush( void ) ; + void write( const uint8_t c ) ; + + void IrqHandler( void ) ; + + using Print::write ; // pull in write(str) and write(buf, size) from Print +}; + +#endif // _UART_ diff --git a/hardware/atmel/cores/sam/USART.cpp b/hardware/atmel/cores/sam/USART.cpp new file mode 100644 index 000000000..d6ef66366 --- /dev/null +++ b/hardware/atmel/cores/sam/USART.cpp @@ -0,0 +1,73 @@ +#include +#include +#include +#include "USART.h" + +// Constructors //////////////////////////////////////////////////////////////// + +USARTClass::USARTClass( ring_buffer *rx_buffer, ring_buffer *tx_buffer, Usart* pUsart, IRQn_Type dwIrq, uint32_t dwId ) +{ + _rx_buffer = rx_buffer ; + _tx_buffer = tx_buffer ; + + _pUsart=pUsart ; + _dwIrq=dwIrq ; + _dwId=dwId ; +} + +// Public Methods ////////////////////////////////////////////////////////////// + +void USARTClass::begin( const uint32_t dwBaudRate ) +{ + /* Configure PMC */ + PMC_EnablePeripheral( _dwId ) ; + + /* Reset and disable receiver & transmitter */ + _pUsart->US_CR = US_CR_RSTRX | US_CR_RSTTX | US_CR_RXDIS | US_CR_TXDIS ; + + /* Configure mode */ + _pUsart->US_MR = US_MR_USART_MODE_NORMAL | US_MR_USCLKS_MCK | US_MR_CHRL_8_BIT | US_MR_PAR_NO | + US_MR_NBSTOP_1_BIT | US_MR_CHMODE_NORMAL; + + /* Configure baudrate */ + /* Asynchronous, no oversampling */ + _pUsart->US_BRGR = (BOARD_MCK / dwBaudRate) / 16 ; + + /* Disable PDC channel */ + _pUsart->US_PTCR = US_PTCR_RXTDIS | US_PTCR_TXTDIS ; + + /* Enable receiver and transmitter */ + _pUsart->US_CR = US_CR_RXEN | US_CR_TXEN ; +} + +void USARTClass::end() +{ +} + +int USARTClass::available( void ) +{ + return 0 ; +} + +int USARTClass::peek( void ) +{ + return 0 ; +} + +int USARTClass::read( void ) +{ + return 0 ; +} + +void USARTClass::flush( void ) +{ +} + +void USARTClass::write( uint8_t c ) +{ +} + +void USARTClass::IrqHandler( void ) +{ +} + diff --git a/hardware/atmel/cores/sam/USART.h b/hardware/atmel/cores/sam/USART.h new file mode 100644 index 000000000..e41265797 --- /dev/null +++ b/hardware/atmel/cores/sam/USART.h @@ -0,0 +1,30 @@ +#ifndef _USART_ +#define _USART_ + +#include +#include "wiring_private.h" + +class USARTClass : public HardwareSerial +{ + protected: + Usart* _pUsart ; + IRQn_Type _dwIrq ; + uint32_t _dwId ; + + public: + USARTClass( ring_buffer *rx_buffer, ring_buffer *tx_buffer, Usart* pUsart, IRQn_Type dwIrq, uint32_t dwId ) ; + + void begin( const uint32_t dwBaudRate ) ; + void end( void ) ; + int available( void ) ; + int peek( void ) ; + int read( void ) ; + void flush( void ) ; + void write( const uint8_t c ) ; + + void IrqHandler( void ) ; + + using Print::write ; // pull in write(str) and write(buf, size) from Print +}; + +#endif // _USART_ diff --git a/hardware/atmel/cores/sam/WCharacter.h b/hardware/atmel/cores/sam/WCharacter.h new file mode 100644 index 000000000..79733b50a --- /dev/null +++ b/hardware/atmel/cores/sam/WCharacter.h @@ -0,0 +1,168 @@ +/* + WCharacter.h - Character utility functions for Wiring & Arduino + Copyright (c) 2010 Hernando Barragan. All right reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef Character_h +#define Character_h + +#include + +// WCharacter.h prototypes +inline boolean isAlphaNumeric(int c) __attribute__((always_inline)); +inline boolean isAlpha(int c) __attribute__((always_inline)); +inline boolean isAscii(int c) __attribute__((always_inline)); +inline boolean isWhitespace(int c) __attribute__((always_inline)); +inline boolean isControl(int c) __attribute__((always_inline)); +inline boolean isDigit(int c) __attribute__((always_inline)); +inline boolean isGraph(int c) __attribute__((always_inline)); +inline boolean isLowerCase(int c) __attribute__((always_inline)); +inline boolean isPrintable(int c) __attribute__((always_inline)); +inline boolean isPunct(int c) __attribute__((always_inline)); +inline boolean isSpace(int c) __attribute__((always_inline)); +inline boolean isUpperCase(int c) __attribute__((always_inline)); +inline boolean isHexadecimalDigit(int c) __attribute__((always_inline)); +inline int toAscii(int c) __attribute__((always_inline)); +inline int toLowerCase(int c) __attribute__((always_inline)); +inline int toUpperCase(int c)__attribute__((always_inline)); + + +// Checks for an alphanumeric character. +// It is equivalent to (isalpha(c) || isdigit(c)). +inline boolean isAlphaNumeric(int c) +{ + return ( isalnum(c) == 0 ? false : true); +} + + +// Checks for an alphabetic character. +// It is equivalent to (isupper(c) || islower(c)). +inline boolean isAlpha(int c) +{ + return ( isalpha(c) == 0 ? false : true); +} + + +// Checks whether c is a 7-bit unsigned char value +// that fits into the ASCII character set. +inline boolean isAscii(int c) +{ + return ( isascii (c) == 0 ? false : true); +} + + +// Checks for a blank character, that is, a space or a tab. +inline boolean isWhitespace(int c) +{ + return ( isblank (c) == 0 ? false : true); +} + + +// Checks for a control character. +inline boolean isControl(int c) +{ + return ( iscntrl (c) == 0 ? false : true); +} + + +// Checks for a digit (0 through 9). +inline boolean isDigit(int c) +{ + return ( isdigit (c) == 0 ? false : true); +} + + +// Checks for any printable character except space. +inline boolean isGraph(int c) +{ + return ( isgraph (c) == 0 ? false : true); +} + + +// Checks for a lower-case character. +inline boolean isLowerCase(int c) +{ + return (islower (c) == 0 ? false : true); +} + + +// Checks for any printable character including space. +inline boolean isPrintable(int c) +{ + return ( isprint (c) == 0 ? false : true); +} + + +// Checks for any printable character which is not a space +// or an alphanumeric character. +inline boolean isPunct(int c) +{ + return ( ispunct (c) == 0 ? false : true); +} + + +// Checks for white-space characters. For the avr-libc library, +// these are: space, formfeed ('\f'), newline ('\n'), carriage +// return ('\r'), horizontal tab ('\t'), and vertical tab ('\v'). +inline boolean isSpace(int c) +{ + return ( isspace (c) == 0 ? false : true); +} + + +// Checks for an uppercase letter. +inline boolean isUpperCase(int c) +{ + return ( isupper (c) == 0 ? false : true); +} + + +// Checks for a hexadecimal digits, i.e. one of 0 1 2 3 4 5 6 7 +// 8 9 a b c d e f A B C D E F. +inline boolean isHexadecimalDigit(int c) +{ + return ( isxdigit (c) == 0 ? false : true); +} + + +// Converts c to a 7-bit unsigned char value that fits into the +// ASCII character set, by clearing the high-order bits. +inline int toAscii(int c) +{ + return toascii (c); +} + + +// Warning: +// Many people will be unhappy if you use this function. +// This function will convert accented letters into random +// characters. + +// Converts the letter c to lower case, if possible. +inline int toLowerCase(int c) +{ + return tolower (c); +} + + +// Converts the letter c to upper case, if possible. +inline int toUpperCase(int c) +{ + return toupper (c); +} + +#endif \ No newline at end of file diff --git a/hardware/atmel/cores/sam/WInterrupts.c b/hardware/atmel/cores/sam/WInterrupts.c new file mode 100644 index 000000000..bb2015e6c --- /dev/null +++ b/hardware/atmel/cores/sam/WInterrupts.c @@ -0,0 +1,23 @@ +#include "board.h" + +#include +#include + +#include "wiring_private.h" + +volatile static voidFuncPtr intFunc[EXTERNAL_NUM_INTERRUPTS]; + +void attachInterrupt(uint8_t interruptNum, void (*userFunc)(void), int mode) { + if(interruptNum < EXTERNAL_NUM_INTERRUPTS) + { + intFunc[interruptNum] = userFunc; + } +} + +void detachInterrupt( uint8_t interruptNum ) +{ + if(interruptNum < EXTERNAL_NUM_INTERRUPTS) + { + intFunc[interruptNum] = 0; + } +} diff --git a/hardware/atmel/cores/sam/WMath.cpp b/hardware/atmel/cores/sam/WMath.cpp new file mode 100644 index 000000000..2120c4cc1 --- /dev/null +++ b/hardware/atmel/cores/sam/WMath.cpp @@ -0,0 +1,60 @@ +/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */ + +/* + Part of the Wiring project - http://wiring.org.co + Copyright (c) 2004-06 Hernando Barragan + Modified 13 August 2006, David A. Mellis for Arduino - http://www.arduino.cc/ + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General + Public License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place, Suite 330, + Boston, MA 02111-1307 USA + + $Id$ +*/ + +extern "C" { + #include "stdlib.h" +} + +void randomSeed(unsigned int seed) +{ + if (seed != 0) { + srandom(seed); + } +} + +long random(long howbig) +{ + if (howbig == 0) { + return 0; + } + return random() % howbig; +} + +long random(long howsmall, long howbig) +{ + if (howsmall >= howbig) { + return howsmall; + } + long diff = howbig - howsmall; + return random(diff) + howsmall; +} + +long map(long x, long in_min, long in_max, long out_min, long out_max) +{ + return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min; +} + +unsigned int makeWord(unsigned int w) { return w; } +unsigned int makeWord(unsigned char h, unsigned char l) { return (h << 8) | l; } \ No newline at end of file diff --git a/hardware/atmel/cores/sam/WString.cpp b/hardware/atmel/cores/sam/WString.cpp new file mode 100644 index 000000000..f90cef01e --- /dev/null +++ b/hardware/atmel/cores/sam/WString.cpp @@ -0,0 +1,645 @@ +/* + WString.cpp - String library for Wiring & Arduino + ...mostly rewritten by Paul Stoffregen... + Copyright (c) 2009-10 Hernando Barragan. All rights reserved. + Copyright 2011, Paul Stoffregen, paul@pjrc.com + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include "WString.h" + + +/*********************************************/ +/* Constructors */ +/*********************************************/ + +String::String(const char *cstr) +{ + init(); + if (cstr) copy(cstr, strlen(cstr)); +} + +String::String(const String &value) +{ + init(); + *this = value; +} + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +String::String(String &&rval) +{ + init(); + move(rval); +} +String::String(StringSumHelper &&rval) +{ + init(); + move(rval); +} +#endif + +String::String(char c) +{ + init(); + char buf[2]; + buf[0] = c; + buf[1] = 0; + *this = buf; +} + +String::String(unsigned char value, unsigned char base) +{ + init(); + char buf[9]; + utoa(value, buf, base); + *this = buf; +} + +String::String(int value, unsigned char base) +{ + init(); + char buf[18]; + itoa(value, buf, base); + *this = buf; +} + +String::String(unsigned int value, unsigned char base) +{ + init(); + char buf[17]; + utoa(value, buf, base); + *this = buf; +} + +String::String(long value, unsigned char base) +{ + init(); + char buf[34]; + ltoa(value, buf, base); + *this = buf; +} + +String::String(unsigned long value, unsigned char base) +{ + init(); + char buf[33]; + ultoa(value, buf, base); + *this = buf; +} + +String::~String() +{ + free(buffer); +} + +/*********************************************/ +/* Memory Management */ +/*********************************************/ + +inline void String::init(void) +{ + buffer = NULL; + capacity = 0; + len = 0; + flags = 0; +} + +void String::invalidate(void) +{ + if (buffer) free(buffer); + buffer = NULL; + capacity = len = 0; +} + +unsigned char String::reserve(unsigned int size) +{ + if (buffer && capacity >= size) return 1; + if (changeBuffer(size)) { + if (len == 0) buffer[0] = 0; + return 1; + } + return 0; +} + +unsigned char String::changeBuffer(unsigned int maxStrLen) +{ + char *newbuffer = (char *)realloc(buffer, maxStrLen + 1); + if (newbuffer) { + buffer = newbuffer; + capacity = maxStrLen; + return 1; + } + return 0; +} + +/*********************************************/ +/* Copy and Move */ +/*********************************************/ + +String & String::copy(const char *cstr, unsigned int length) +{ + if (!reserve(length)) { + invalidate(); + return *this; + } + len = length; + strcpy(buffer, cstr); + return *this; +} + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +void String::move(String &rhs) +{ + if (buffer) { + if (capacity >= rhs.len) { + strcpy(buffer, rhs.buffer); + len = rhs.len; + rhs.len = 0; + return; + } else { + free(buffer); + } + } + buffer = rhs.buffer; + capacity = rhs.capacity; + len = rhs.len; + rhs.buffer = NULL; + rhs.capacity = 0; + rhs.len = 0; +} +#endif + +String & String::operator = (const String &rhs) +{ + if (this == &rhs) return *this; + + if (rhs.buffer) copy(rhs.buffer, rhs.len); + else invalidate(); + + return *this; +} + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +String & String::operator = (String &&rval) +{ + if (this != &rval) move(rval); + return *this; +} + +String & String::operator = (StringSumHelper &&rval) +{ + if (this != &rval) move(rval); + return *this; +} +#endif + +String & String::operator = (const char *cstr) +{ + if (cstr) copy(cstr, strlen(cstr)); + else invalidate(); + + return *this; +} + +/*********************************************/ +/* concat */ +/*********************************************/ + +unsigned char String::concat(const String &s) +{ + return concat(s.buffer, s.len); +} + +unsigned char String::concat(const char *cstr, unsigned int length) +{ + unsigned int newlen = len + length; + if (!cstr) return 0; + if (length == 0) return 1; + if (!reserve(newlen)) return 0; + strcpy(buffer + len, cstr); + len = newlen; + return 1; +} + +unsigned char String::concat(const char *cstr) +{ + if (!cstr) return 0; + return concat(cstr, strlen(cstr)); +} + +unsigned char String::concat(char c) +{ + char buf[2]; + buf[0] = c; + buf[1] = 0; + return concat(buf, 1); +} + +unsigned char String::concat(unsigned char num) +{ + char buf[4]; + itoa(num, buf, 10); + return concat(buf, strlen(buf)); +} + +unsigned char String::concat(int num) +{ + char buf[7]; + itoa(num, buf, 10); + return concat(buf, strlen(buf)); +} + +unsigned char String::concat(unsigned int num) +{ + char buf[6]; + utoa(num, buf, 10); + return concat(buf, strlen(buf)); +} + +unsigned char String::concat(long num) +{ + char buf[12]; + ltoa(num, buf, 10); + return concat(buf, strlen(buf)); +} + +unsigned char String::concat(unsigned long num) +{ + char buf[11]; + ultoa(num, buf, 10); + return concat(buf, strlen(buf)); +} + +/*********************************************/ +/* Concatenate */ +/*********************************************/ + +StringSumHelper & operator + (const StringSumHelper &lhs, const String &rhs) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(rhs.buffer, rhs.len)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr) +{ + StringSumHelper &a = const_cast(lhs); + if (!cstr || !a.concat(cstr, strlen(cstr))) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, char c) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(c)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, int num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, long num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) a.invalidate(); + return a; +} + +/*********************************************/ +/* Comparison */ +/*********************************************/ + +int String::compareTo(const String &s) const +{ + if (!buffer || !s.buffer) { + if (s.buffer && s.len > 0) return 0 - *(unsigned char *)s.buffer; + if (buffer && len > 0) return *(unsigned char *)buffer; + return 0; + } + return strcmp(buffer, s.buffer); +} + +unsigned char String::equals(const String &s2) const +{ + return (len == s2.len && compareTo(s2) == 0); +} + +unsigned char String::equals(const char *cstr) const +{ + if (len == 0) return (cstr == NULL || *cstr == 0); + if (cstr == NULL) return buffer[0] == 0; + return strcmp(buffer, cstr) == 0; +} + +unsigned char String::operator<(const String &rhs) const +{ + return compareTo(rhs) < 0; +} + +unsigned char String::operator>(const String &rhs) const +{ + return compareTo(rhs) > 0; +} + +unsigned char String::operator<=(const String &rhs) const +{ + return compareTo(rhs) <= 0; +} + +unsigned char String::operator>=(const String &rhs) const +{ + return compareTo(rhs) >= 0; +} + +unsigned char String::equalsIgnoreCase( const String &s2 ) const +{ + if (this == &s2) return 1; + if (len != s2.len) return 0; + if (len == 0) return 1; + const char *p1 = buffer; + const char *p2 = s2.buffer; + while (*p1) { + if (tolower(*p1++) != tolower(*p2++)) return 0; + } + return 1; +} + +unsigned char String::startsWith( const String &s2 ) const +{ + if (len < s2.len) return 0; + return startsWith(s2, 0); +} + +unsigned char String::startsWith( const String &s2, unsigned int offset ) const +{ + if (offset > len - s2.len || !buffer || !s2.buffer) return 0; + return strncmp( &buffer[offset], s2.buffer, s2.len ) == 0; +} + +unsigned char String::endsWith( const String &s2 ) const +{ + if ( len < s2.len || !buffer || !s2.buffer) return 0; + return strcmp(&buffer[len - s2.len], s2.buffer) == 0; +} + +/*********************************************/ +/* Character Access */ +/*********************************************/ + +char String::charAt(unsigned int loc) const +{ + return operator[](loc); +} + +void String::setCharAt(unsigned int loc, char c) +{ + if (loc < len) buffer[loc] = c; +} + +char & String::operator[](unsigned int index) +{ + static char dummy_writable_char; + if (index >= len || !buffer) { + dummy_writable_char = 0; + return dummy_writable_char; + } + return buffer[index]; +} + +char String::operator[]( unsigned int index ) const +{ + if (index >= len || !buffer) return 0; + return buffer[index]; +} + +void String::getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index) const +{ + if (!bufsize || !buf) return; + if (index >= len) { + buf[0] = 0; + return; + } + unsigned int n = bufsize - 1; + if (n > len - index) n = len - index; + strncpy((char *)buf, buffer + index, n); + buf[n] = 0; +} + +/*********************************************/ +/* Search */ +/*********************************************/ + +int String::indexOf(char c) const +{ + return indexOf(c, 0); +} + +int String::indexOf( char ch, unsigned int fromIndex ) const +{ + if (fromIndex >= len) return -1; + const char* temp = strchr(buffer + fromIndex, ch); + if (temp == NULL) return -1; + return temp - buffer; +} + +int String::indexOf(const String &s2) const +{ + return indexOf(s2, 0); +} + +int String::indexOf(const String &s2, unsigned int fromIndex) const +{ + if (fromIndex >= len) return -1; + const char *found = strstr(buffer + fromIndex, s2.buffer); + if (found == NULL) return -1; + return found - buffer; +} + +int String::lastIndexOf( char theChar ) const +{ + return lastIndexOf(theChar, len - 1); +} + +int String::lastIndexOf(char ch, int fromIndex) const +{ + if (fromIndex >= len || fromIndex < 0) return -1; + char tempchar = buffer[fromIndex + 1]; + buffer[fromIndex + 1] = '\0'; + char* temp = strrchr( buffer, ch ); + buffer[fromIndex + 1] = tempchar; + if (temp == NULL) return -1; + return temp - buffer; +} + +int String::lastIndexOf(const String &s2) const +{ + return lastIndexOf(s2, len - s2.len); +} + +int String::lastIndexOf(const String &s2, int fromIndex) const +{ + if (s2.len == 0 || len == 0 || s2.len > len || fromIndex < 0) return -1; + if (fromIndex >= len) fromIndex = len - 1; + int found = -1; + for (char *p = buffer; p <= buffer + fromIndex; p++) { + p = strstr(p, s2.buffer); + if (!p) break; + if (p - buffer <= fromIndex) found = p - buffer; + } + return found; +} + +String String::substring( unsigned int left ) const +{ + return substring(left, len); +} + +String String::substring(unsigned int left, unsigned int right) const +{ + if (left > right) { + unsigned int temp = right; + right = left; + left = temp; + } + String out; + if (left > len) return out; + if (right > len) right = len; + char temp = buffer[right]; // save the replaced character + buffer[right] = '\0'; + out = buffer + left; // pointer arithmetic + buffer[right] = temp; //restore character + return out; +} + +/*********************************************/ +/* Modification */ +/*********************************************/ + +void String::replace(char find, char replace) +{ + if (!buffer) return; + for (char *p = buffer; *p; p++) { + if (*p == find) *p = replace; + } +} + +void String::replace(const String& find, const String& replace) +{ + if (len == 0 || find.len == 0) return; + int diff = replace.len - find.len; + char *readFrom = buffer; + char *foundAt; + if (diff == 0) { + while ((foundAt = strstr(readFrom, find.buffer)) != NULL) { + memcpy(foundAt, replace.buffer, replace.len); + readFrom = foundAt + replace.len; + } + } else if (diff < 0) { + char *writeTo = buffer; + while ((foundAt = strstr(readFrom, find.buffer)) != NULL) { + unsigned int n = foundAt - readFrom; + memcpy(writeTo, readFrom, n); + writeTo += n; + memcpy(writeTo, replace.buffer, replace.len); + writeTo += replace.len; + readFrom = foundAt + find.len; + len += diff; + } + strcpy(writeTo, readFrom); + } else { + unsigned int size = len; // compute size needed for result + while ((foundAt = strstr(readFrom, find.buffer)) != NULL) { + readFrom = foundAt + find.len; + size += diff; + } + if (size == len) return; + if (size > capacity && !changeBuffer(size)) return; // XXX: tell user! + int index = len - 1; + while ((index = lastIndexOf(find, index)) >= 0) { + readFrom = buffer + index + find.len; + memmove(readFrom + diff, readFrom, len - (readFrom - buffer)); + len += diff; + buffer[len] = 0; + memcpy(buffer + index, replace.buffer, replace.len); + index--; + } + } +} + +void String::toLowerCase(void) +{ + if (!buffer) return; + for (char *p = buffer; *p; p++) { + *p = tolower(*p); + } +} + +void String::toUpperCase(void) +{ + if (!buffer) return; + for (char *p = buffer; *p; p++) { + *p = toupper(*p); + } +} + +void String::trim(void) +{ + if (!buffer || len == 0) return; + char *begin = buffer; + while (isspace(*begin)) begin++; + char *end = buffer + len - 1; + while (isspace(*end) && end >= begin) end--; + len = end + 1 - begin; + if (begin > buffer) memcpy(buffer, begin, len); + buffer[len] = 0; +} + +/*********************************************/ +/* Parsing / Conversion */ +/*********************************************/ + +long String::toInt(void) const +{ + if (buffer) return atol(buffer); + return 0; +} + + diff --git a/hardware/atmel/cores/sam/WString.h b/hardware/atmel/cores/sam/WString.h new file mode 100644 index 000000000..01f144ac6 --- /dev/null +++ b/hardware/atmel/cores/sam/WString.h @@ -0,0 +1,204 @@ +/* + WString.h - String library for Wiring & Arduino + ...mostly rewritten by Paul Stoffregen... + Copyright (c) 2009-10 Hernando Barragan. All right reserved. + Copyright 2011, Paul Stoffregen, paul@pjrc.com + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef String_class_h +#define String_class_h +#ifdef __cplusplus + +#include +#include +#include + +// When compiling programs with this class, the following gcc parameters +// dramatically increase performance and memory (RAM) efficiency, typically +// with little or no increase in code size. +// -felide-constructors +// -std=c++0x + +class __FlashStringHelper; +#define F(string_literal) (reinterpret_cast<__FlashStringHelper *>(PSTR(string_literal))) + +// An inherited class for holding the result of a concatenation. These +// result objects are assumed to be writable by subsequent concatenations. +class StringSumHelper; + +// The string class +class String +{ + // use a function pointer to allow for "if (s)" without the + // complications of an operator bool(). for more information, see: + // http://www.artima.com/cppsource/safebool.html + typedef void (String::*StringIfHelperType)() const; + void StringIfHelper() const {} + +public: + // constructors + // creates a copy of the initial value. + // if the initial value is null or invalid, or if memory allocation + // fails, the string will be marked as invalid (i.e. "if (s)" will + // be false). + String(const char *cstr = ""); + String(const String &str); + #ifdef __GXX_EXPERIMENTAL_CXX0X__ + String(String &&rval); + String(StringSumHelper &&rval); + #endif + explicit String(char c); + explicit String(unsigned char, unsigned char base=10); + explicit String(int, unsigned char base=10); + explicit String(unsigned int, unsigned char base=10); + explicit String(long, unsigned char base=10); + explicit String(unsigned long, unsigned char base=10); + ~String(void); + + // memory management + // return true on success, false on failure (in which case, the string + // is left unchanged). reserve(0), if successful, will validate an + // invalid string (i.e., "if (s)" will be true afterwards) + unsigned char reserve(unsigned int size); + inline unsigned int length(void) const {return len;} + + // creates a copy of the assigned value. if the value is null or + // invalid, or if the memory allocation fails, the string will be + // marked as invalid ("if (s)" will be false). + String & operator = (const String &rhs); + String & operator = (const char *cstr); + #ifdef __GXX_EXPERIMENTAL_CXX0X__ + String & operator = (String &&rval); + String & operator = (StringSumHelper &&rval); + #endif + + // concatenate (works w/ built-in types) + + // returns true on success, false on failure (in which case, the string + // is left unchanged). if the argument is null or invalid, the + // concatenation is considered unsucessful. + unsigned char concat(const String &str); + unsigned char concat(const char *cstr); + unsigned char concat(char c); + unsigned char concat(unsigned char c); + unsigned char concat(int num); + unsigned char concat(unsigned int num); + unsigned char concat(long num); + unsigned char concat(unsigned long num); + + // if there's not enough memory for the concatenated value, the string + // will be left unchanged (but this isn't signalled in any way) + String & operator += (const String &rhs) {concat(rhs); return (*this);} + String & operator += (const char *cstr) {concat(cstr); return (*this);} + String & operator += (char c) {concat(c); return (*this);} + String & operator += (unsigned char num) {concat(num); return (*this);} + String & operator += (int num) {concat(num); return (*this);} + String & operator += (unsigned int num) {concat(num); return (*this);} + String & operator += (long num) {concat(num); return (*this);} + String & operator += (unsigned long num) {concat(num); return (*this);} + + friend StringSumHelper & operator + (const StringSumHelper &lhs, const String &rhs); + friend StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr); + friend StringSumHelper & operator + (const StringSumHelper &lhs, char c); + friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char num); + friend StringSumHelper & operator + (const StringSumHelper &lhs, int num); + friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num); + friend StringSumHelper & operator + (const StringSumHelper &lhs, long num); + friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num); + + // comparison (only works w/ Strings and "strings") + operator StringIfHelperType() const { return buffer ? &String::StringIfHelper : 0; } + int compareTo(const String &s) const; + unsigned char equals(const String &s) const; + unsigned char equals(const char *cstr) const; + unsigned char operator == (const String &rhs) const {return equals(rhs);} + unsigned char operator == (const char *cstr) const {return equals(cstr);} + unsigned char operator != (const String &rhs) const {return !equals(rhs);} + unsigned char operator != (const char *cstr) const {return !equals(cstr);} + unsigned char operator < (const String &rhs) const; + unsigned char operator > (const String &rhs) const; + unsigned char operator <= (const String &rhs) const; + unsigned char operator >= (const String &rhs) const; + unsigned char equalsIgnoreCase(const String &s) const; + unsigned char startsWith( const String &prefix) const; + unsigned char startsWith(const String &prefix, unsigned int offset) const; + unsigned char endsWith(const String &suffix) const; + + // character acccess + char charAt(unsigned int index) const; + void setCharAt(unsigned int index, char c); + char operator [] (unsigned int index) const; + char& operator [] (unsigned int index); + void getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index=0) const; + void toCharArray(char *buf, unsigned int bufsize, unsigned int index=0) const + {getBytes((unsigned char *)buf, bufsize, index);} + + // search + int indexOf( char ch ) const; + int indexOf( char ch, unsigned int fromIndex ) const; + int indexOf( const String &str ) const; + int indexOf( const String &str, unsigned int fromIndex ) const; + int lastIndexOf( char ch ) const; + int lastIndexOf( char ch, int fromIndex ) const; + int lastIndexOf( const String &str ) const; + int lastIndexOf( const String &str, int fromIndex ) const; + String substring( unsigned int beginIndex ) const; + String substring( unsigned int beginIndex, unsigned int endIndex ) const; + + // modification + void replace(char find, char replace); + void replace(const String& find, const String& replace); + void toLowerCase(void); + void toUpperCase(void); + void trim(void); + + // parsing/conversion + long toInt(void) const; + +protected: + char *buffer; // the actual char array + unsigned int capacity; // the array length minus one (for the '\0') + unsigned int len; // the String length (not counting the '\0') + unsigned char flags; // unused, for future features +protected: + void init(void); + void invalidate(void); + unsigned char changeBuffer(unsigned int maxStrLen); + unsigned char concat(const char *cstr, unsigned int length); + + // copy and move + String & copy(const char *cstr, unsigned int length); + #ifdef __GXX_EXPERIMENTAL_CXX0X__ + void move(String &rhs); + #endif +}; + +class StringSumHelper : public String +{ +public: + StringSumHelper(const String &s) : String(s) {} + StringSumHelper(const char *p) : String(p) {} + StringSumHelper(char c) : String(c) {} + StringSumHelper(unsigned char num) : String(num) {} + StringSumHelper(int num) : String(num) {} + StringSumHelper(unsigned int num) : String(num) {} + StringSumHelper(long num) : String(num) {} + StringSumHelper(unsigned long num) : String(num) {} +}; + +#endif // __cplusplus +#endif // String_class_h diff --git a/hardware/atmel/cores/sam/binary.h b/hardware/atmel/cores/sam/binary.h new file mode 100644 index 000000000..af1498033 --- /dev/null +++ b/hardware/atmel/cores/sam/binary.h @@ -0,0 +1,515 @@ +#ifndef Binary_h +#define Binary_h + +#define B0 0 +#define B00 0 +#define B000 0 +#define B0000 0 +#define B00000 0 +#define B000000 0 +#define B0000000 0 +#define B00000000 0 +#define B1 1 +#define B01 1 +#define B001 1 +#define B0001 1 +#define B00001 1 +#define B000001 1 +#define B0000001 1 +#define B00000001 1 +#define B10 2 +#define B010 2 +#define B0010 2 +#define B00010 2 +#define B000010 2 +#define B0000010 2 +#define B00000010 2 +#define B11 3 +#define B011 3 +#define B0011 3 +#define B00011 3 +#define B000011 3 +#define B0000011 3 +#define B00000011 3 +#define B100 4 +#define B0100 4 +#define B00100 4 +#define B000100 4 +#define B0000100 4 +#define B00000100 4 +#define B101 5 +#define B0101 5 +#define B00101 5 +#define B000101 5 +#define B0000101 5 +#define B00000101 5 +#define B110 6 +#define B0110 6 +#define B00110 6 +#define B000110 6 +#define B0000110 6 +#define B00000110 6 +#define B111 7 +#define B0111 7 +#define B00111 7 +#define B000111 7 +#define B0000111 7 +#define B00000111 7 +#define B1000 8 +#define B01000 8 +#define B001000 8 +#define B0001000 8 +#define B00001000 8 +#define B1001 9 +#define B01001 9 +#define B001001 9 +#define B0001001 9 +#define B00001001 9 +#define B1010 10 +#define B01010 10 +#define B001010 10 +#define B0001010 10 +#define B00001010 10 +#define B1011 11 +#define B01011 11 +#define B001011 11 +#define B0001011 11 +#define B00001011 11 +#define B1100 12 +#define B01100 12 +#define B001100 12 +#define B0001100 12 +#define B00001100 12 +#define B1101 13 +#define B01101 13 +#define B001101 13 +#define B0001101 13 +#define B00001101 13 +#define B1110 14 +#define B01110 14 +#define B001110 14 +#define B0001110 14 +#define B00001110 14 +#define B1111 15 +#define B01111 15 +#define B001111 15 +#define B0001111 15 +#define B00001111 15 +#define B10000 16 +#define B010000 16 +#define B0010000 16 +#define B00010000 16 +#define B10001 17 +#define B010001 17 +#define B0010001 17 +#define B00010001 17 +#define B10010 18 +#define B010010 18 +#define B0010010 18 +#define B00010010 18 +#define B10011 19 +#define B010011 19 +#define B0010011 19 +#define B00010011 19 +#define B10100 20 +#define B010100 20 +#define B0010100 20 +#define B00010100 20 +#define B10101 21 +#define B010101 21 +#define B0010101 21 +#define B00010101 21 +#define B10110 22 +#define B010110 22 +#define B0010110 22 +#define B00010110 22 +#define B10111 23 +#define B010111 23 +#define B0010111 23 +#define B00010111 23 +#define B11000 24 +#define B011000 24 +#define B0011000 24 +#define B00011000 24 +#define B11001 25 +#define B011001 25 +#define B0011001 25 +#define B00011001 25 +#define B11010 26 +#define B011010 26 +#define B0011010 26 +#define B00011010 26 +#define B11011 27 +#define B011011 27 +#define B0011011 27 +#define B00011011 27 +#define B11100 28 +#define B011100 28 +#define B0011100 28 +#define B00011100 28 +#define B11101 29 +#define B011101 29 +#define B0011101 29 +#define B00011101 29 +#define B11110 30 +#define B011110 30 +#define B0011110 30 +#define B00011110 30 +#define B11111 31 +#define B011111 31 +#define B0011111 31 +#define B00011111 31 +#define B100000 32 +#define B0100000 32 +#define B00100000 32 +#define B100001 33 +#define B0100001 33 +#define B00100001 33 +#define B100010 34 +#define B0100010 34 +#define B00100010 34 +#define B100011 35 +#define B0100011 35 +#define B00100011 35 +#define B100100 36 +#define B0100100 36 +#define B00100100 36 +#define B100101 37 +#define B0100101 37 +#define B00100101 37 +#define B100110 38 +#define B0100110 38 +#define B00100110 38 +#define B100111 39 +#define B0100111 39 +#define B00100111 39 +#define B101000 40 +#define B0101000 40 +#define B00101000 40 +#define B101001 41 +#define B0101001 41 +#define B00101001 41 +#define B101010 42 +#define B0101010 42 +#define B00101010 42 +#define B101011 43 +#define B0101011 43 +#define B00101011 43 +#define B101100 44 +#define B0101100 44 +#define B00101100 44 +#define B101101 45 +#define B0101101 45 +#define B00101101 45 +#define B101110 46 +#define B0101110 46 +#define B00101110 46 +#define B101111 47 +#define B0101111 47 +#define B00101111 47 +#define B110000 48 +#define B0110000 48 +#define B00110000 48 +#define B110001 49 +#define B0110001 49 +#define B00110001 49 +#define B110010 50 +#define B0110010 50 +#define B00110010 50 +#define B110011 51 +#define B0110011 51 +#define B00110011 51 +#define B110100 52 +#define B0110100 52 +#define B00110100 52 +#define B110101 53 +#define B0110101 53 +#define B00110101 53 +#define B110110 54 +#define B0110110 54 +#define B00110110 54 +#define B110111 55 +#define B0110111 55 +#define B00110111 55 +#define B111000 56 +#define B0111000 56 +#define B00111000 56 +#define B111001 57 +#define B0111001 57 +#define B00111001 57 +#define B111010 58 +#define B0111010 58 +#define B00111010 58 +#define B111011 59 +#define B0111011 59 +#define B00111011 59 +#define B111100 60 +#define B0111100 60 +#define B00111100 60 +#define B111101 61 +#define B0111101 61 +#define B00111101 61 +#define B111110 62 +#define B0111110 62 +#define B00111110 62 +#define B111111 63 +#define B0111111 63 +#define B00111111 63 +#define B1000000 64 +#define B01000000 64 +#define B1000001 65 +#define B01000001 65 +#define B1000010 66 +#define B01000010 66 +#define B1000011 67 +#define B01000011 67 +#define B1000100 68 +#define B01000100 68 +#define B1000101 69 +#define B01000101 69 +#define B1000110 70 +#define B01000110 70 +#define B1000111 71 +#define B01000111 71 +#define B1001000 72 +#define B01001000 72 +#define B1001001 73 +#define B01001001 73 +#define B1001010 74 +#define B01001010 74 +#define B1001011 75 +#define B01001011 75 +#define B1001100 76 +#define B01001100 76 +#define B1001101 77 +#define B01001101 77 +#define B1001110 78 +#define B01001110 78 +#define B1001111 79 +#define B01001111 79 +#define B1010000 80 +#define B01010000 80 +#define B1010001 81 +#define B01010001 81 +#define B1010010 82 +#define B01010010 82 +#define B1010011 83 +#define B01010011 83 +#define B1010100 84 +#define B01010100 84 +#define B1010101 85 +#define B01010101 85 +#define B1010110 86 +#define B01010110 86 +#define B1010111 87 +#define B01010111 87 +#define B1011000 88 +#define B01011000 88 +#define B1011001 89 +#define B01011001 89 +#define B1011010 90 +#define B01011010 90 +#define B1011011 91 +#define B01011011 91 +#define B1011100 92 +#define B01011100 92 +#define B1011101 93 +#define B01011101 93 +#define B1011110 94 +#define B01011110 94 +#define B1011111 95 +#define B01011111 95 +#define B1100000 96 +#define B01100000 96 +#define B1100001 97 +#define B01100001 97 +#define B1100010 98 +#define B01100010 98 +#define B1100011 99 +#define B01100011 99 +#define B1100100 100 +#define B01100100 100 +#define B1100101 101 +#define B01100101 101 +#define B1100110 102 +#define B01100110 102 +#define B1100111 103 +#define B01100111 103 +#define B1101000 104 +#define B01101000 104 +#define B1101001 105 +#define B01101001 105 +#define B1101010 106 +#define B01101010 106 +#define B1101011 107 +#define B01101011 107 +#define B1101100 108 +#define B01101100 108 +#define B1101101 109 +#define B01101101 109 +#define B1101110 110 +#define B01101110 110 +#define B1101111 111 +#define B01101111 111 +#define B1110000 112 +#define B01110000 112 +#define B1110001 113 +#define B01110001 113 +#define B1110010 114 +#define B01110010 114 +#define B1110011 115 +#define B01110011 115 +#define B1110100 116 +#define B01110100 116 +#define B1110101 117 +#define B01110101 117 +#define B1110110 118 +#define B01110110 118 +#define B1110111 119 +#define B01110111 119 +#define B1111000 120 +#define B01111000 120 +#define B1111001 121 +#define B01111001 121 +#define B1111010 122 +#define B01111010 122 +#define B1111011 123 +#define B01111011 123 +#define B1111100 124 +#define B01111100 124 +#define B1111101 125 +#define B01111101 125 +#define B1111110 126 +#define B01111110 126 +#define B1111111 127 +#define B01111111 127 +#define B10000000 128 +#define B10000001 129 +#define B10000010 130 +#define B10000011 131 +#define B10000100 132 +#define B10000101 133 +#define B10000110 134 +#define B10000111 135 +#define B10001000 136 +#define B10001001 137 +#define B10001010 138 +#define B10001011 139 +#define B10001100 140 +#define B10001101 141 +#define B10001110 142 +#define B10001111 143 +#define B10010000 144 +#define B10010001 145 +#define B10010010 146 +#define B10010011 147 +#define B10010100 148 +#define B10010101 149 +#define B10010110 150 +#define B10010111 151 +#define B10011000 152 +#define B10011001 153 +#define B10011010 154 +#define B10011011 155 +#define B10011100 156 +#define B10011101 157 +#define B10011110 158 +#define B10011111 159 +#define B10100000 160 +#define B10100001 161 +#define B10100010 162 +#define B10100011 163 +#define B10100100 164 +#define B10100101 165 +#define B10100110 166 +#define B10100111 167 +#define B10101000 168 +#define B10101001 169 +#define B10101010 170 +#define B10101011 171 +#define B10101100 172 +#define B10101101 173 +#define B10101110 174 +#define B10101111 175 +#define B10110000 176 +#define B10110001 177 +#define B10110010 178 +#define B10110011 179 +#define B10110100 180 +#define B10110101 181 +#define B10110110 182 +#define B10110111 183 +#define B10111000 184 +#define B10111001 185 +#define B10111010 186 +#define B10111011 187 +#define B10111100 188 +#define B10111101 189 +#define B10111110 190 +#define B10111111 191 +#define B11000000 192 +#define B11000001 193 +#define B11000010 194 +#define B11000011 195 +#define B11000100 196 +#define B11000101 197 +#define B11000110 198 +#define B11000111 199 +#define B11001000 200 +#define B11001001 201 +#define B11001010 202 +#define B11001011 203 +#define B11001100 204 +#define B11001101 205 +#define B11001110 206 +#define B11001111 207 +#define B11010000 208 +#define B11010001 209 +#define B11010010 210 +#define B11010011 211 +#define B11010100 212 +#define B11010101 213 +#define B11010110 214 +#define B11010111 215 +#define B11011000 216 +#define B11011001 217 +#define B11011010 218 +#define B11011011 219 +#define B11011100 220 +#define B11011101 221 +#define B11011110 222 +#define B11011111 223 +#define B11100000 224 +#define B11100001 225 +#define B11100010 226 +#define B11100011 227 +#define B11100100 228 +#define B11100101 229 +#define B11100110 230 +#define B11100111 231 +#define B11101000 232 +#define B11101001 233 +#define B11101010 234 +#define B11101011 235 +#define B11101100 236 +#define B11101101 237 +#define B11101110 238 +#define B11101111 239 +#define B11110000 240 +#define B11110001 241 +#define B11110010 242 +#define B11110011 243 +#define B11110100 244 +#define B11110101 245 +#define B11110110 246 +#define B11110111 247 +#define B11111000 248 +#define B11111001 249 +#define B11111010 250 +#define B11111011 251 +#define B11111100 252 +#define B11111101 253 +#define B11111110 254 +#define B11111111 255 + +#endif diff --git a/hardware/atmel/cores/sam/build_gcc/Makefile b/hardware/atmel/cores/sam/build_gcc/Makefile new file mode 100644 index 000000000..ae2da8a03 --- /dev/null +++ b/hardware/atmel/cores/sam/build_gcc/Makefile @@ -0,0 +1,24 @@ +# Makefile for compiling libboard +BOARD = + +SUBMAKE_OPTIONS=--no-builtin-rules --no-builtin-variables + +#------------------------------------------------------------------------------- +# Rules +#------------------------------------------------------------------------------- + +all: sam3s_ek + +.PHONY: sam3s_ek +sam3s_ek: + @echo --- Making sam3s_ek + @$(MAKE) DEBUG=1 $(SUBMAKE_OPTIONS) -f arduino_sam3s_ek.mk + @$(MAKE) $(SUBMAKE_OPTIONS) -f arduino_sam3s_ek.mk + +.PHONY: clean +clean: + @echo --- Cleaning sam3s_ek + @$(MAKE) $(SUBMAKE_OPTIONS) -f arduino_sam3s_ek.mk $@ + @$(MAKE) DEBUG=1 $(SUBMAKE_OPTIONS) -f arduino_sam3s_ek.mk $@ + + diff --git a/hardware/atmel/cores/sam/build_gcc/arduino_sam3s_ek.mk b/hardware/atmel/cores/sam/build_gcc/arduino_sam3s_ek.mk new file mode 100644 index 000000000..812b24f67 --- /dev/null +++ b/hardware/atmel/cores/sam/build_gcc/arduino_sam3s_ek.mk @@ -0,0 +1,146 @@ +# Makefile for compiling libboard +.SUFFIXES: .o .a .c .s + +CHIP=sam3s4 +BOARD=sam3s_ek +LIBNAME=arduino_sam3s_ek +TOOLCHAIN=gcc + +#------------------------------------------------------------------------------- +# Path +#------------------------------------------------------------------------------- + +# Output directories +OUTPUT_BIN = ../lib + +# Libraries +PROJECT_BASE_PATH = .. +BSP_PATH = ../../../../tools + +#------------------------------------------------------------------------------- +# Files +#------------------------------------------------------------------------------- + +vpath %.h $(PROJECT_BASE_PATH) $(BSP_PATH)/libchip_sam3s $(BSP_PATH)/libboard_sam3s-ek +vpath %.c $(PROJECT_BASE_PATH) +vpath %.cpp $(PROJECT_BASE_PATH) $(PROJECT_BASE_PATH)/sam3s_ek + +VPATH+=$(PROJECT_BASE_PATH) + +INCLUDES = -I$(PROJECT_BASE_PATH) +INCLUDES = -I$(PROJECT_BASE_PATH)/sam3s_ek +INCLUDES += -I$(BSP_PATH)/libchip_sam3s +INCLUDES += -I$(BSP_PATH)/libboard_sam3s-ek + +#------------------------------------------------------------------------------- +ifdef DEBUG +include debug.mk +else +include release.mk +endif + +#------------------------------------------------------------------------------- +# Tools +#------------------------------------------------------------------------------- + +include $(TOOLCHAIN).mk + +#------------------------------------------------------------------------------- +ifdef DEBUG +OUTPUT_OBJ=debug +OUTPUT_LIB=$(LIBNAME)_$(TOOLCHAIN)_dbg.a +else +OUTPUT_OBJ=release +OUTPUT_LIB=$(LIBNAME)_$(TOOLCHAIN)_rel.a +endif + +OUTPUT_PATH=$(OUTPUT_OBJ)_sam3s_ek + +#------------------------------------------------------------------------------- +# C source files and objects +#------------------------------------------------------------------------------- +C_SRC=$(wildcard $(PROJECT_BASE_PATH)/*.c) + +C_OBJ_TEMP = $(patsubst %.c, %.o, $(notdir $(C_SRC))) + +# during development, remove some files +C_OBJ_FILTER=wiring_analog.o wiring_digital.o wiring_pulse.o + +C_OBJ=$(filter-out $(C_OBJ_FILTER), $(C_OBJ_TEMP)) + +#------------------------------------------------------------------------------- +# CPP source files and objects +#------------------------------------------------------------------------------- +CPP_SRC=$(wildcard $(PROJECT_BASE_PATH)/*.cpp) + +CPP_OBJ_TEMP = $(patsubst %.cpp, %.o, $(notdir $(CPP_SRC))) + +# during development, remove some files +CPP_OBJ_FILTER=Tone.o WMath.o WString.o + +CPP_OBJ=$(filter-out $(CPP_OBJ_FILTER), $(CPP_OBJ_TEMP)) + +#------------------------------------------------------------------------------- +# Assembler source files and objects +#------------------------------------------------------------------------------- +A_SRC=$(wildcard $(PROJECT_BASE_PATH)/*.s) + +A_OBJ_TEMP=$(patsubst %.s, %.o, $(notdir $(A_SRC))) + +# during development, remove some files +A_OBJ_FILTER= + +A_OBJ=$(filter-out $(A_OBJ_FILTER), $(A_OBJ_TEMP)) + +#------------------------------------------------------------------------------- +# Rules +#------------------------------------------------------------------------------- +all: sam3s_ek + +sam3s_ek: create_output $(OUTPUT_LIB) + +.PHONY: create_output +create_output: + @echo --- Preparing sam3s_ek files in $(OUTPUT_PATH) $(OUTPUT_BIN) + @echo ------------------------- + @echo *$(C_SRC) + @echo ------------------------- + @echo *$(C_OBJ) + @echo ------------------------- + @echo *$(addprefix $(OUTPUT_PATH)/, $(C_OBJ)) + @echo ------------------------- + @echo *$(CPP_SRC) + @echo ------------------------- + @echo *$(CPP_OBJ) + @echo ------------------------- + @echo *$(addprefix $(OUTPUT_PATH)/, $(CPP_OBJ)) + @echo ------------------------- + @echo *$(A_SRC) + @echo ------------------------- + +# -@mkdir $(subst /,$(SEP),$(OUTPUT_BIN)) 1>NUL 2>&1 + -mkdir $(subst /,$(SEP),$(OUTPUT_BIN)) + -@mkdir $(OUTPUT_PATH) 1>NUL 2>&1 + +$(addprefix $(OUTPUT_PATH)/,$(C_OBJ)): $(OUTPUT_PATH)/%.o: %.c +# @$(CC) -v -c $(CFLAGS) $< -o $@ + @$(CC) -c $(CFLAGS) $< -o $@ + +$(addprefix $(OUTPUT_PATH)/,$(CPP_OBJ)): $(OUTPUT_PATH)/%.o: %.cpp + @$(CC) -c $(CPPFLAGS) $< -o $@ + +$(addprefix $(OUTPUT_PATH)/,$(A_OBJ)): $(OUTPUT_PATH)/%.o: %.s + @$(AS) -c $(ASFLAGS) $< -o $@ + +$(OUTPUT_LIB): $(addprefix $(OUTPUT_PATH)/, $(C_OBJ)) $(addprefix $(OUTPUT_PATH)/, $(CPP_OBJ)) $(addprefix $(OUTPUT_PATH)/, $(A_OBJ)) + @$(AR) -v -r "$(OUTPUT_BIN)/$@" $^ + @$(NM) "$(OUTPUT_BIN)/$@" > "$(OUTPUT_BIN)/$@.txt" + +.PHONY: clean +clean: + @echo --- Cleaning sam3s_ek files [$(OUTPUT_PATH)$(SEP)*.o] + -@$(RM) $(OUTPUT_PATH) 1>NUL 2>&1 + -@$(RM) $(OUTPUT_BIN)/$(OUTPUT_LIB) 1>NUL 2>&1 + +#$(addprefix $(OUTPUT_PATH)/,$(C_OBJ)): $(OUTPUT_PATH)/%.o: $(PROJECT_BASE_PATH)/board.h $(wildcard $(PROJECT_BASE_PATH)/include/*.h) +#$(addprefix $(OUTPUT_PATH)/,$(CPP_OBJ)): $(OUTPUT_PATH)/%.o: $(PROJECT_BASE_PATH)/board.h $(wildcard $(PROJECT_BASE_PATH)/include/*.h) diff --git a/hardware/atmel/cores/sam/build_gcc/debug.mk b/hardware/atmel/cores/sam/build_gcc/debug.mk new file mode 100644 index 000000000..3ab3f8066 --- /dev/null +++ b/hardware/atmel/cores/sam/build_gcc/debug.mk @@ -0,0 +1,7 @@ +# Optimization level +# -O1 Optimize +# -O2 Optimize even more +# -O3 Optimize yet more +# -O0 Reduce compilation time and make debugging produce the expected results +# -Os Optimize for size +OPTIMIZATION = -g -O0 -DDEBUG diff --git a/hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/HardwareSerial.o b/hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/HardwareSerial.o new file mode 100644 index 0000000000000000000000000000000000000000..423f51d7b3435847d7f55ca0c3b187acdd174197 GIT binary patch literal 7084 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 a^usR6KT1SD9FY90MD)WU$sZx2AN~*IHCj#p literal 0 HcmV?d00001 diff --git a/hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/UART.o b/hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/UART.o new file mode 100644 index 0000000000000000000000000000000000000000..ab711e714ca86015fe3c818aeb5f701d7e12752f GIT binary patch literal 25736 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 literal 0 HcmV?d00001 diff --git a/hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/USART.o b/hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/USART.o new file mode 100644 index 0000000000000000000000000000000000000000..1dc2ef23a90a1c88d87bf084439e46d432e62f7c GIT binary patch literal 25512 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 literal 0 HcmV?d00001 diff --git a/hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/WInterrupts.o b/hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/WInterrupts.o new file mode 100644 index 0000000000000000000000000000000000000000..48ee53efa16bb54b994fdcfe35dc5cb69d982301 GIT binary patch literal 6024 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 MxA9CJaJF&&7m%D(e*gdg literal 0 HcmV?d00001 diff --git a/hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/wiring.o b/hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/wiring.o new file mode 100644 index 0000000000000000000000000000000000000000..6a4a018bf1f1de54783ea0ead5e8ba01d18ebf0e GIT binary patch literal 15344 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 literal 0 HcmV?d00001 diff --git a/hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/wiring_shift.o b/hardware/atmel/cores/sam/build_gcc/debug_sam3s_ek/wiring_shift.o new file mode 100644 index 0000000000000000000000000000000000000000..2e7a85636acc56fa716eb605c701c0c7e876b6d2 GIT binary patch literal 9472 zcma)B3vgW3c|PafeMndDhi&-17o#c$}{r>m=pa0%_?%Au)?d&XjFb-1cRJoqPSi=@asR{%tqmB_O1KO^xs9;>0R;`BVvMQyj8%pFg5(3E? zqP7MV(!H)l-%;t7wW>1KP^as4dx(MRgT-nsI5cc7VH?4+1jL|rfj`PjjD?8dvsxrE zQ1=~`+bYq;55s7d>1IH`8c<4Sak|9_N>5fG+zUfXhb};2>9R*{fE9efK=?tp*@0j> zQ&3h}@GMQr!k;4qg7@JP!u@{ZUbYdIR$1UhBMijoUKY3>!oc&?tYPxNLlpNUNY+sr z9|alYDfAppVN&12QFbFv^)CM}9xwWLJzl%|k3Bx1${*JDnb6ZgT-du%mHiVF)oNDG z6w0!HDr~^1Cwn&Zw{W$Z%bX=-&lyLnxzcGsmG*y#ajo-ZhI&`nM&}6G{}kUQXC-~# z3q6CRR`W7v1kh z?0kuN|6ABC&TI5NFQK+M9W=fm+IHt78vl>5JDj7`UKHb9&MEr-T-YwBjCp?{#&M^I z#vcpY@3fHpr5NAsY@zQbp%bR&0p~%ozY^nnoI&QjBIGrnWa zX=;BRddaX8&Tg{*8~O*s9(F#%s;-()cJs7$PLWq(-Y0hRQSHRZ>oBjO-F!?t-zH&+ z{vqw$!n$qYAJ)!!@&Vx=)y_)tLGgb=JKth)q44*R-fsRP;!z(K`{UYqhxy8c|4Z$h zBwsH6&uAw>dnf#T_dyQA0<$Q_$*9w2yavq^RBKdx7Ig`|{@ap4Y3I00a&som* znXg&=-?N;znQx`=A6O2SVr5@1{CUgC)BXnGe{MPVv0tl%|HN{hq5W#%uUO9AjCZ5( z)3)<0?bir@)ONnYde;hn%y#~i@z+UxSO|k$=;l3f#S5C#|7*fUF!&-)74dXd+3Ukx z1uL(h1Rbc^6vFH363SCmjH0VPKq*$$uUJskuOSIkT}3g$s=bhes)le5tH9sDA+Y!t zxIERXVAB|Eco=bN-lOFLl2}J;+L0l+@JZ;c=0MGdDoJ^}|`gJW>XZ7`|RuOP5qsy`1A$8mE;g?Mw-KL$oGrONt3w*D*%^tep@$Hvdq zjW^s%Zkfv+YD_D=+@%ky1-gT}HE>qy7>+GC62<6iN}>xV(S;jdcrY=B2(INAqpy=p zY7y6+(1U?20%{#(!Hs==Dp+w8f*^aZLbPo-$UaoMQkK&27i?3ND?ov8i|$szYF9wV z@MGxD>j-1sg01j?UvSyKn!s>Yp_f3G7NEvpW2x(S)|acRP?Onjf!E2c1Ig@gDxaOq zB~!Vn!A-3jH@394t>3(9U?`m#XldCnmLA%$KbhQ+$c?YhWHYJtsl-rv!{(NoS~hKf zy7*VBPiK;2lfx-hRD&pFvtxP2OOB=|2J?yWw)_U4oe>PC?){BE$?<$TuV{8Col9r- z59UYHBZZbEX0P&vVeCg*M!ALT>*#Ll1BpgXq_ZB8$qy!S!;|R@C1`0fn@bHQ$J@ZM ze=5knW3kd-xMTPJ+uprse|7{r86CPSv||Mp5_C>1*62gKZ#(_&etXI@u*!w_gG>#4W7QmL0`a8pqfuIa_vt_kV z&6Y*xk+shwo1RC;Zq1H|>6XgO+#+Ufc*Na(J?DX%IS-WS4$2U3jtn<@i41c?3X_BJ zrs&Nam>l~@+3!(?cnbjZrOXV-)_^FHnfluIdcMZa$flnyk-@j!=WFU_%}TX19-mB~ zY;f7JhIw(WRZDfSLVpj1IkKz8ktAdK93Ado#Ts0l$BgJT)4Ti$UMI7^T?E* zn?qT1Wz)tNm);$?9#=u}dT?%Le!NB?=EyLQIkM?_WVli1*hO5sVqWB$J*K~L^y}(t z4V_l!r2|gq-yb+~pyxdHuz8+O<~N=>In~tJb6)GEyPvr8$dp=J{l;ZT7K5`oPad%@ z*%yCw;_{L0KeO$3PF&8{oT0W(w69zU+p{g)cuI$1bMlCNK_kn_BjL6G{PyJ|O`YKj zwc(dLr(agz@#=Kz`{cm44t(~&ty0^DGpwZQjjdD2j0)a4VV~E?e`%_=b8%-QB3GZG zj``>6E16klRbHf(4uQUGD!QD%jEY`=yI74B!)4S`f5b=KEUcjUTSBqFpqq%t4SlEy zP#nLF-!WKQYQ}Gs;Thrrmf9x~+Po5C8M9+BbkAggdK5%g4w`-*h*v>j%V0tAH4Uxpkn!eeDg%>kqHN z@xlG+!oVm5hZ4EeK%y|78pD1dm&y;|Z9FhEnI0P+#LM5LibrF}HI~inkC@YBCZFD) zNexHPG&P(kBrsXeaEDt=@1AI{iuHF7_8#6oIWm&U8GT=r>e6PJS?%nN#di&M_;N6` zWJ#h-H@s`M!!SE#`f*@yDxb<7Obu@=Qk#lYTanuA2HER#xY>w$_V&m3_7ArDnVC?Z za@|n5nLGEStQy z*iCo3+g)Fmi56$Gv2})=DR$$`#5cAX$9-%NcC3>r_tD_vAU#(l7t)=S6xi9@wM$Cl zB&h2FKlkz*uYNJ@@ut;--gp<~rXqDq@!_ObuiUp?J<;9b-x2FZ{)u=t=hhfQn4xr` zCpVmO?||4ITqsiwOwn~ymz2COE`oTmyWL(r5Xsfz6&M-ICfo$wp16Mxs_`n`V&Zo0 z?BXNV-P0E{d^{@gdAV^Hm=&Vf!QxFC>x5HrdB~4qF6KEgrS6kjW1Uh?l$|o&;H`29 zm%gJ=$fbuS3v$cEcZkcLp8mm(!FX(sG4H0B>zAp*1lYNY<(exb_gt|iGz)1=c=v49 zF?yles5GCX*Q8EFpS#O8Y1k-tR>isVk?4-~^_a?v%Mw=rZ-u32&psr&bI;yLG-7^3 z7;7e#3HI!h?0xJBicMiX9ZlsDW3gf1>Z|UIMz=;*_sQ>;$enA~M!M34RAlA{%#D(u zqZO-Yg1=gnz5!$~ii?ptyuQ0lg`9AAxm6!%)C=??yGbwBOY}8Zwku(F6+)wd7J`B1vaPvVMLnox$&`T-J4^9YeKvZ$9HWBjE$@3x*ZO&rVDZ zWfJ2lWS_|gSphG)5?Lab$m}l_c@np5%u2N+v*Y6_+zl-qz1=Md?@lfWG?GI)bn3So z{9MF+A1;j`NJiDzBlzT$p!`CWx54Hi+^H?U&?XFyy4jmLEz8JO^uhA-`c#qhe0#1 z7q6?v{n`SN8D2bY&HV9d5s!7VFMJlgc-*dea|fy3Lc9qQGCbV_;QjHM5N{eX#>13~ z@%{|7=L1shz$Dg^km2dLHT1`O!dD;X?bY{H(4G%NWTCu|gbYvjEO>vs?%Uw~@t#3EZmK!oMjT$eAAcUk|PP9vAOx|A!d4ERoUKiXb_^9j;2fc5BGV#kz?KEN? z8nfVMaF=#@-c!u#>6e3MR*zo+dM0Z*mj%PW1tZ4u4_i62)@R48-%k{cxRT5a8!JKS zdR}Slj}}e1Qp^n7Jn4R(S7v6|_#dKw*yc%@k=W)=_w!9A-%J$VK{LZvv-!m{N>H|1 zV*bg>ULD6#kNMvL^akU0c?^*J-8g7}3`adz!dV|Y@ln}qOwG27pNdxw&-n?m62GAM zeH1^2htv4Eml)fZ!$!$tdQ*wvnV$s6!?oJNt-@|vOYkvXkl)kD^BP;2+Vw=-LhD4{ zCb(6wLvWYi?+X6D;IQDmf;mBc(_@}#L9XTG9};|A@F_u!22o!tc&#A+e@gjnf?a~2 z5&Q!|{`Z%5#{?f2{A3*ImIh~U$L&kMdH_@>}l!Ha@6?p-r~!DhiW!Kh%LU{WwI zc)#Eyf*%Xw%f5+QCRi=lD7Zv0B6x$~I>9!<+Xe3uyjyTYups!yf{zP6E%;R;_B|&A zUnJt;{Ep~00bN^+bNUvVL J!^nH}{U3Br7L5P^ literal 0 HcmV?d00001 diff --git a/hardware/atmel/cores/sam/build_gcc/gcc.mk b/hardware/atmel/cores/sam/build_gcc/gcc.mk new file mode 100644 index 000000000..b2f29fdca --- /dev/null +++ b/hardware/atmel/cores/sam/build_gcc/gcc.mk @@ -0,0 +1,63 @@ + +# Tool suffix when cross-compiling +#CROSS_COMPILE = ../../../../tools/CodeSourcery_arm/bin/arm-none-eabi- +CROSS_COMPILE = C:/CodeSourcery_2011.03-42/bin/arm-none-eabi- + +# Compilation tools +AR = $(CROSS_COMPILE)ar +CC = $(CROSS_COMPILE)gcc +AS = $(CROSS_COMPILE)as +#LD = $(CROSS_COMPILE)ld +#SIZE = $(CROSS_COMPILE)size +NM = $(CROSS_COMPILE)nm +#OBJCOPY = $(CROSS_COMPILE)objcopy +RM=cs-rm -Rf +SEP=\\ + +# --------------------------------------------------------------------------------------- +# C Flags + +CFLAGS += -Wall -Wchar-subscripts -Wcomment -Wformat=2 -Wimplicit-int +CFLAGS += -Werror-implicit-function-declaration -Wmain -Wparentheses +CFLAGS += -Wsequence-point -Wreturn-type -Wswitch -Wtrigraphs -Wunused +CFLAGS += -Wuninitialized -Wunknown-pragmas -Wfloat-equal -Wundef +CFLAGS += -Wshadow -Wpointer-arith -Wbad-function-cast -Wwrite-strings +CFLAGS += -Wsign-compare -Waggregate-return -Wstrict-prototypes +CFLAGS += -Wmissing-prototypes -Wmissing-declarations +CFLAGS += -Wformat -Wmissing-format-attribute -Wno-deprecated-declarations +CFLAGS += -Wpacked -Wredundant-decls -Wnested-externs -Winline -Wlong-long +CFLAGS += -Wunreachable-code +CFLAGS += -Wcast-align +#CFLAGS += -Wmissing-noreturn +#CFLAGS += -Wconversion + +CFLAGS += --param max-inline-insns-single=500 -mcpu=cortex-m3 -mthumb -mlong-calls -ffunction-sections +CFLAGS += $(OPTIMIZATION) $(INCLUDES) -D$(CHIP) + +# To reduce application size use only integer printf function. +CFLAGS += -Dprintf=iprintf + +# --------------------------------------------------------------------------------------- +# CPP Flags + +CPPFLAGS += -Wall -Wchar-subscripts -Wcomment -Wformat=2 +CPPFLAGS += -Wmain -Wparentheses -Wcast-align -Wunreachable-code +CPPFLAGS += -Wsequence-point -Wreturn-type -Wswitch -Wtrigraphs -Wunused +CPPFLAGS += -Wuninitialized -Wunknown-pragmas -Wfloat-equal -Wundef +CPPFLAGS += -Wshadow -Wpointer-arith -Wwrite-strings +CPPFLAGS += -Wsign-compare -Waggregate-return -Wmissing-declarations +CPPFLAGS += -Wformat -Wmissing-format-attribute -Wno-deprecated-declarations +CPPFLAGS += -Wpacked -Wredundant-decls -Winline -Wlong-long +#CPPFLAGS += -Wmissing-noreturn +#CPPFLAGS += -Wconversion + +CPPFLAGS += --param max-inline-insns-single=500 -mcpu=cortex-m3 -mthumb -mlong-calls -ffunction-sections +CPPFLAGS += $(OPTIMIZATION) $(INCLUDES) -D$(CHIP) + +# To reduce application size use only integer printf function. +CPPFLAGS += -Dprintf=iprintf + +# --------------------------------------------------------------------------------------- +# ASM Flags + +ASFLAGS = -mcpu=cortex-m3 -mthumb -Wall -g $(OPTIMIZATION) $(INCLUDES) diff --git a/hardware/atmel/cores/sam/build_gcc/release.mk b/hardware/atmel/cores/sam/build_gcc/release.mk new file mode 100644 index 000000000..b4e815985 --- /dev/null +++ b/hardware/atmel/cores/sam/build_gcc/release.mk @@ -0,0 +1,8 @@ + +# Optimization level +# -O1 Optimize +# -O2 Optimize even more +# -O3 Optimize yet more +# -O0 Reduce compilation time and make debugging produce the expected results +# -Os Optimize for size +OPTIMIZATION = -Os diff --git a/hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/HardwareSerial.o b/hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/HardwareSerial.o new file mode 100644 index 0000000000000000000000000000000000000000..b1960b7bd1547958246301b72b994d862bb31a92 GIT binary patch literal 708 zcma)2%}xSA4DPTCh$l4|{}Qua6oX9oy?Bxk!~=Vg2QafRiJOR!*&)iwSMX7M9ACpH z(3aWC>WL=beEr%^r=7R{@Ky)`Yyv8^dml<=t%;+B)rlK+E(a)b^7-<-QBzymrB7RdbW zF8VwhrQZ>Ka#G_uV%~{THz=q%&0IwIh#f=;k?r?^b!CjPaX;3~*|-m1-yA3Qey4R& h@6RNZ&%Q{SrdgW@d4M}*CNIk9kv6eUtegNn5Iko@* literal 0 HcmV?d00001 diff --git a/hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/Print.o b/hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/Print.o new file mode 100644 index 0000000000000000000000000000000000000000..ce1b50f4291b508c83859c324503969829c5ae32 GIT binary patch literal 13216 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 IxM!96FMiVawg3PC literal 0 HcmV?d00001 diff --git a/hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/UART.o b/hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/UART.o new file mode 100644 index 0000000000000000000000000000000000000000..ce68cd8c99edfc5acf3fc4c8646aa66f2f335768 GIT binary patch literal 7252 zcmcIoTWnlM8J^u^JC1vEwkCBera~*pZVtdznODp=Ip#QGI2Z<3JJE5=n}psM0JPLQa|8iUE-)1a@rH{3D+<4 zL75+v`C*wKL7pnKmYyr!Y7^^2qB4pK81+pR_LMTESB~z!nJJxG|GangoZG6l?YNUE zt)9!2LVe-&p>QT&86~8T`=R96_?=&Owa~oQQhIniG*I`EVTf+y&!K1L*N2Qy|4iu@ zM?bsMQrb0pweWcUb|F)Y+!HTt-1(E){I0k;B*Ycg*0|;~rwYkprqq@XjjxV20!Ns} z8=;r4Ul-S?%yww4?s(I9viQjH)zQBdezmV{?$kYz%gi;Ld~4&APm=!$@B2#b_NUQ~ zG+GWx9HQ8ZOdHzA{q|Q4xgDxmCWVkU<`+AG?h9M?V4U%vF9!O za&)x2J33LUTG77VL?YhX-!stnjp#spFy1GId(pwP%v@1~oQW z$Xiumu)Ltjz%a<3cW)6APcJl(4(6K7wd9!MYcn-qi!)GSrs55hM zYKmtwQ@-rO<^{7@GIJ$sCf`LHk9DN5_52M6kei=Izg2dISt}Z2wt7}7ZgZr;oOQlf9$BpYcKE2R zq6LwgFYRZBl|iM#n}q? zG%$MHM^VSdaSxz^aO~R*kU7WAxVXwySzkp?I+~v%&hMX)T#R3QS>#VjrDzqvZ`+teiVs~ z^?iT}Ro`zIAamBY;o>}fgd=?siDP~Lg|F&+Ptiy7!}?+%CT@POZlO%`%f|Ym6371g z43IhNJL%#)eS{-@yCshG9S2U;_r9X96(cT9jR2=UkG)FVZi%CQS(ncn$93?r z2IAxLti-YZ77HQ}jNKn;`relMdR&;N?`2J2r=ssEV0m8FIIav#?{}}{qKw8sc0=Pk z0KPQplSuSGnfd;p@vVc8=MFHB?*onR1@I-&PKo|+GvB{7zEM1D){LAWTUv0iojtCD_nmYIC`#ZtdGV9 zoM-odyF$UFF^+OHdG;PUR@t_ub<5;jb9iGsHto<>Ut5z()c#>KjRXk7|7U)xms^1$rBpi69@% zjBf_M3WAFGE5XGW;&C60l7TO$AfNgrMeVyaK0ei%?+J~sRpXj`8!TaY9 z4j07?ftOV=13PEbwv}tN8|6&`o}f@DUFX#2;U6s z1i|N{?hF*KUu&lw+&4oEYVEWm`(}uPT08Bqz8QjUT75Ib5#K?{z>XKxM?0WzhH&p6 zxyBIR;-Zrq-tOyG8-bmR_|+YXd}YH!7emx*d=1XtMtc;kd|JKq1j(nB7(p%WVI4o} z_z^K9ecDMPSf9^J|5?Xx6IY}kb^LbmDsnd3E#71YIr+auqIk3hBlrsYBXTxs|Ck-* z@t{{3RF^j*G#qDwhLXnd!oPv=($-lqlW(|Ou~_sQ1q zg6?hO^OcI|tcuROc<`NQpoK3hgO&2mF;MB<90qIo{x47~Z|c&MsqC@hGTp_daWP#f zST-)Fvsvd}IJ;85SS;tWkesd9iJ)Nb@{K4)%G+V+4Ki$fITlcyN^EtT7l3PbVRZlH z-#|mi%yiHl3%Z*x%g|->MOZdFf62^NR%|PKp=eiEX!0^sgK6A3R^`QOdVKyqb%p0i z!&$xuBXXsDb}G?J)R%BOe<9I_@^UddPgnlg>g9@+EtVISMw~%xx@Du0DNJLo7QB*< z#pJdUYm&bFY>3I@JhsPOui?|O{i|*+&bZ%Kv3>5he3&*DSd5RMS@+vGJS^*J;lg5l zZoe=t%4l7Lzw55waMoRu;W>BzqIx>3D5w2`@~F&dJ(5o+80EB6hI3z>58Xw0Uh?E6 z5BLK0xL|YiE=b&S(m(Y8{rCWN^iN9t6H@;a{tr;RX{kT$?qL+4_Tg~G{l2F8`5$v= BdoTb1 literal 0 HcmV?d00001 diff --git a/hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/USART.o b/hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/USART.o new file mode 100644 index 0000000000000000000000000000000000000000..dc37c4af49947e3f9ae970376eb8816f72deae58 GIT binary patch literal 6948 zcmcIoUu+yl9iF?f(O6B`@=eIjM zanGg_Kj}R4o8LFzd^5BAoArEaY~o}tms4Un)vHoZshc~ZNc&(^^r{i{NEGjfPuzeh z8K-~Dl*dhZ0%hYA{=g#MLhQAw+jzTv{I#}|yUz^Q?mYRzskawz^z5H~{N0Y~h1ngC z{rvs+-W&dRzUQ;mH*XcXD~KF_L;X4$bk`T7;>SCGcBS#!o3k(9+EdYI+kdcQc4YS1 z+4knB-*{tZgoyRokFz}Z@j)-#q`Kgg} z)1yoN>Z&`AIyE}_P@#8fWi6Zw!pntIhYuGfYR#Z9&|fZ>`i~wN9C)xWSQ;t~s1fe9 zANbXp%6%Ty_R*EF8EhPxJgRo=zGHG%zO!v_?$fz_x+`~YZh!7zn<}kdUT*qTl+7?M z7o~=dO;wuro4zVlA*(cUZnA_nzgl9be|9W5Kfi7%Fy{$KWq+; zpL?RdrJn6DY^`)VEUkB=+&>;ZecG?jF9qTD_Ia}&;R;_-yp7W{w`HX0WwZd2p`7;d ztvZgU9h1?fHtCcG(+)@nu>w_^TUlNX>PRYF7r)sIYt^-8fXs3+Tv==UFM0E7n^JdM z9eAcOH-8DgFXM-B^mB0!qg`-cYk_;z!admnH(}wv-U2sm;k*_&Y7%|37Va~s^Bj(k zc%|l1w=Hj+Zj{7n`C%5|*X8=w0|JBQz{s22Zu>E3i*I?zNM`(4G4+@g;Uk#L}z=y?WpTVInw%S7J|wAuQI z<2ZL2tZ=^y-`02C(zgdO(f4=MZGF@s9H=Jx{%mlvepeW@O!R3~Y<*XNp}tOo748q= z+xl);`t~9w`UYdZWc|KlVumi!S2Q@$cTE7ML^!hZF)rC(;;8SQIGoJ=3E*sfzp(Um z0W12hnsH@+zlWG;Af?owF*xzR&!A-pNA_xrOZ2^fR_fayhZB9*fwT3!Zs|J!tmylT z8CUfE5HZm}N~!??Xf_Cm3@xu4E!&d=cFXCdt_g9B+0x#q+K;+~9t-|-d z!?yvx4#dS|KmOzJT>~HU3i$@{6TSnefI{WXe82q>d|klV`+MEu;~6P@{SM#r;IqF| zI2LWv!M%cjtOetO3k1hT*iR8S9ap2j(#HqR*7rK}Eds&$K7=2_5&yE`lRae~IgFSX z$K`JwI4og9+V8{ql*KU^x||zuiA@9dT@Gf9Tr`$ui6g%Q9ScZG!|*sCcG-g;=V0^o z?Ne&m>L`4GWz24GQ~&zV4r+CW?SfxcEpFDCmE-uk)h9ANUjV6ToX%N3Ijv)iR@el~ zG~T4FKE7G0X`H56K0J(;X~nPE)HE`Ame0=Y)PK<7lhZKf(CTw38ERS;9KM1R?{WBg zBD}m4=_wU=)9R4Z|9*#`Csk@1r$cuB4@CHMmE`n@`)KuG+8H&iiVi5C*JSG)0H4lBLipmhZ#9Fjf|R&GsC8)anqQMGh?QvGhZYe??f6z zO(TP4`!l1Zrq#o#gPKPsV-#vd(_j$XKL%j`|@1IKd4?YKEKsE@zwN8lw!;VzY_-~{eR%c@%iR- zLd`xnwm)wCc)UJ!kwF-roV&5UJV#l-)A-N9=c+Q3G5(^3@5TxL6XP@9js1Vi_;4dV ze{%ePI=*ZH->hytUmYgL$9%_BmzDE5zY*he-MjI;%ov}Uyc^F;)xoRiI<+*{XsAO? zb!c8~ep%_XX08yOnA`)p&E_)CX-+QW+;+KCbKB)Atui_4jn#SUS;3`pV=)MEvFv%# zovyc5zf`Nwdzh8i2>abRZR0}98FjS0$R}C#)Y_WcBq1zzoxmItelzKq;2sV9Ck*oph#}jXK-sx>J8kI zua^fK_VE;d?BhY3+s`ZYC`+u*e*yj|FhKwS literal 0 HcmV?d00001 diff --git a/hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/WInterrupts.o b/hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/WInterrupts.o new file mode 100644 index 0000000000000000000000000000000000000000..0eeda867de63c27c9a298aebd505ae00d6617068 GIT binary patch literal 1176 zcma)5&2G~`5T1?Qlok*nYE^y&GN=O6kX4cf2_bQ)0twLO0*7+MaV*tR^CNpBkrM|l z9Qy!$gdVx~HFynf++aTMZfwkjk;XIM%(t_%kNQFgvLeW*91*oNSnFm4pRUs; z?fK`I;;{G2tIY=p@A=M;${{`Eh{uu3j5_G`UU>e8*&+#}Wa$kW4euyck=JRp+p@La z>~@}bUHMFQ=%B?5f+!fpBp$K5)|(|N`rI7uQ+0EFxKXLQTVh-6IJd-YaYx*DNv6w* z3Px;IqV0+Gc%dRW4pcyLl%^z;=u{#o1EqrSdE4E&r1I2o0g?gBQt@nw2)I*<;kF1T%(;wuZ zF)PnxuA@X>*=bwA797Y;Ry#Z3@2pEWMl283&K#-dyr{;(YwX`(MSqwR&QPrPh7&J2 zX2sUC*xF*;rJuiT9M)NNtE0|eogiP_5!lUo%4@h(XMkR{pxay=zGXN=F4c^m|96e^ zyhGat;0}p@_Q#*k#o?*kV~8`NW}W+M8jQP8$1Oizy{uG*w5w=$Oz~9p7t@f+Pp|yo NxCYKv;bWmb>>tpYYE=LL literal 0 HcmV?d00001 diff --git a/hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/main.o b/hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/main.o new file mode 100644 index 0000000000000000000000000000000000000000..3704990693ccf4f28415fdfb540efe2ee488b967 GIT binary patch literal 1296 zcma)6J#Q015S{bcv11@Wl!y=zI-~$5CM(-94bVg;xFC@bP$F4p`y@_^?bCTJk_v(7 zY54*CfKX7wPoblxqd3&cp{nK$!hX1~s__YWR9jw4nasY!-J9vV<;Cxn`; z$Qh}8b{~J}8vXTMzSvsY$|vW|>8ZTS$E4fo-1BPBCbM`D#3x?2UiS_{9eAxqv#A=p zJMGqOudVK?mh3f9=m&m36z3+~QfCtD;CSb7SC*>f!{x$iam`tGF1Z`dWoOg5RunZo z8EL-{t7BtdS`UR<)X>+ysQz>+Dh`emgKFf5V^Mog4;7H#&j-mdiEwzFPYfobQ7}eB zW__*Wus_qmbZ(>n23L^gaW17abEa8MA$70AlINy)k!P+%?0M?0TQTC&!BI_Z$K6qPJ<{1uW}r-dfh@=l(>(&Ml{W z)`d{c~MD9$c2QIYp>nijy4L%9gGXH5JRYS&6^d9-$~jB6A%5IhHe z1RcTUxe; z36yXgYMBOl7Rk|M5=pO@{B87R<5%H$*aN#4#m!`1;k?KidKPd9d{+ftJY>6MEEbvE I;Wi%GABH$>^8f$< literal 0 HcmV?d00001 diff --git a/hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/wiring.o b/hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/wiring.o new file mode 100644 index 0000000000000000000000000000000000000000..5aaca739d0b07e2077a28553035b479dc013dae2 GIT binary patch literal 1956 zcma)6&rcIk5T2#wM**=^45(2{Ac{dY{4x=v30R~BN+5v2TiLb`Ty49!T|g2O50H4! zi!m|Y^rkmsB1fVJ{{#O4Zp4F$CdPOIzuDbqAFBr^na+IkzBfBF@AW;rksi}DjihMQ zMHNK!-UHQxE}@HJbd>70waFLBx*azZUrFxo(YyVmUB;C9iN!1KZ|M-}Fm5lDthnbe9VOd9Xmv-qZl%)yrWFm1T-Zf{f z+Bsow#FO3K@wDlPczH7H-jwYptO+?SytxI};|oyis(FEUaUD_O|q}(IGu=I0ot2a+!2n6m$;iMYB*a z5%59Iwj@|EOzd&vc~LMnrc7QGIjfXc6U=Rt=gr*ROv)(b3&K`Xn4)VM!Ky)7Kbpak@DPiB?`3Jw- zC`quAcM*O>i9e|I@<)9R^Em%CsG4sWSmuCBvX2S)DsNO-Q+YQ7yfI)oBb9eAz)J)F ztB)e$Y9Cul9~_r`JPzc$1v~?lB71s-fST_K^0gtxb7_Fee9z%?zdUc2H_&d^^L}`Z z^(7Q%yW&NOKEvsg0G2r{%}{v<7>BX&mK|RtkFA_JFKwZqVFY-8E0pWwTDb=`-zN-t z8!;&|pTyFt@i2Wqka4!5Kh=8C(4k6rUHu~CFx9IGfR6xI?ya1<%vTfOt2cx5)dtpa zIEsXj`SABDUt(GaQ#rgI3Dl#WJo6g@{05g_`HyPctU+8kT*DY2CEV(z2eTPKP@4+Tu z&znWzzRlyMoGsi}*nN{1M&~o5X4%LV1f{L@v{(~`ael04#-}q0tF&Y;uiAnfY`1$e q)|#-F3f6ii=a%3{{pwIZ-;65!v0Zzb=rZH8L|56yiBfFaiGBkxFwZam literal 0 HcmV?d00001 diff --git a/hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/wiring_shift.o b/hardware/atmel/cores/sam/build_gcc/release_sam3s_ek/wiring_shift.o new file mode 100644 index 0000000000000000000000000000000000000000..789d2f7d82cc7a7010c8aff1a45217c099fa68b9 GIT binary patch literal 1288 zcma)5&2JJ>5TC~`OIwRY)cTb)OVUu3vH^-Q@t{=d5@Ly3O*CH20&BabfLWGkPd4%D z#aq4kCm2umVC>DS_8(~D$$Ba=F$51fv&+EBMJJh^uiyL4d-L`^zrL&sA%I0d0)`R5 zmKOwbE+7G6n1Iwlw-D4P^;ddm4&tgVVtd{E=1wtuW4i-WV_y>bR`F9OBt?4CkHU9F zk@qR{KA%S)VyeDV6jy(~`?{OfKYZ)HfREgpd8hT)$h_B0Z^pNgN0fS^Blb(ZP$!{_ zLm_az%feg-yFQ*`p>SDE+-bJ$s%dYi#bi=lwj5K>a zjsaSw)dI~n*ELFNtu^bBQ)-N6ZnhC$ZPx2%1D(Z{vSv7rZB^Qi+2VoxhdqZFx+0~I z_3ml7Fwl2nXbC6v<53*dNaj$-Q2&La*^TzSk2w~(@64ke=Oo%gEJV;AK_v_+^}B}Z z=X;6q5-JPfNUosz`5@@6Cq9}1^W8?D_-LObpHY*p=Y6O~`T!Nr`ozlu{6Z(g0b0V4 z97E-qP&|)?$K>>dab$VsRC+Ka5KIqw~`l{Csb*kjESg^Ks19pO>NYoAYF) z!EU{*^w&>q>@QRDi5AggKGM;XBC=#A}8bdk*{VP%I zKQk=5+!sdTOBfS=2{lSL{M53o#_B`&RcTe2bzrsz{Kjh5s^u8#E2dF{zJJfg*Y5%7 R$8kZ4F^a>GNcM#X9^ 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 literal 0 HcmV?d00001 diff --git a/hardware/atmel/cores/sam/lib/arduino_sam3s_ek_gcc_dbg.a.txt b/hardware/atmel/cores/sam/lib/arduino_sam3s_ek_gcc_dbg.a.txt new file mode 100644 index 000000000..3498404b4 --- /dev/null +++ b/hardware/atmel/cores/sam/lib/arduino_sam3s_ek_gcc_dbg.a.txt @@ -0,0 +1,199 @@ + +WInterrupts.o: +00000000 r LED_BLUE +00000001 r LED_GREEN +00000002 r LED_RED +00000005 r MISO +00000004 r MOSI +00000006 r SCK +00000003 r SS +00000000 T attachInterrupt +00000000 T detachInterrupt +00000000 b intFunc + +wiring.o: +00000004 r APinDescription + U GetTickCount + U LowLevelInit +00000002 r MISO +00000001 r MOSI +00000000 t NVIC_SetPriority + U PIO_Configure +00000003 r SCK +00000000 r SS +00000000 t SysTick_Config +00000000 T SysTick_Handler + U TimeTick_Increment + U WDT_Disable +00000000 T Wait +00000000 T delayMicroseconds +00000000 T init +00000000 T micros +00000000 T millis +00000008 b timer0_fract +00000004 B timer0_millis +00000000 B timer0_overflow_count + +wiring_shift.o: +00000004 r APinDescription +00000002 r MISO +00000001 r MOSI +00000003 r SCK +00000000 r SS + U digitalRead + U digitalWrite +00000000 T shiftIn +00000000 T shiftOut + +HardwareSerial.o: +00000004 r _ZL15APinDescription +00000000 r _ZL2SS +00000003 r _ZL3SCK +00000002 r _ZL4MISO +00000001 r _ZL4MOSI + +Print.o: +00000030 r _ZL15APinDescription +0000002b r _ZL2SS +0000002e r _ZL3SCK +0000002d r _ZL4MISO +0000002c r _ZL4MOSI +00000000 T _ZN5Print10printFloatEdh +00000000 T _ZN5Print11printNumberEmh +00000000 T _ZN5Print5printEPKc +00000000 T _ZN5Print5printERK6String +00000000 T _ZN5Print5printEc +00000000 T _ZN5Print5printEdi +00000000 T _ZN5Print5printEhi +00000000 T _ZN5Print5printEii +00000000 T _ZN5Print5printEji +00000000 T _ZN5Print5printEli +00000000 T _ZN5Print5printEmi +00000000 T _ZN5Print5writeEPKc +00000000 T _ZN5Print5writeEPKhj +00000000 T _ZN5Print7printlnEPKc +00000000 T _ZN5Print7printlnERK6String +00000000 T _ZN5Print7printlnEc +00000000 T _ZN5Print7printlnEdi +00000000 T _ZN5Print7printlnEhi +00000000 T _ZN5Print7printlnEii +00000000 T _ZN5Print7printlnEji +00000000 T _ZN5Print7printlnEli +00000000 T _ZN5Print7printlnEmi +00000000 T _ZN5Print7printlnEv +00000000 W _ZNK6String6lengthEv + U _ZNK6StringixEj +0000001c R _ZTI5Print +00000024 R _ZTS5Print +00000008 R _ZTV5Print + U _ZTVN10__cxxabiv117__class_type_infoE + U __aeabi_d2iz + U __aeabi_d2uiz + U __aeabi_dadd + U __aeabi_dcmplt + U __aeabi_ddiv + U __aeabi_dmul + U __aeabi_dsub + U __aeabi_i2d + U __aeabi_ui2d + U __aeabi_unwind_cpp_pr1 + U __cxa_pure_virtual + +UART.o: + U PMC_DisablePeripheral + U PMC_EnablePeripheral +00000048 r _ZL15APinDescription +00000043 r _ZL2SS +00000046 r _ZL3SCK +00000045 r _ZL4MISO +00000044 r _ZL4MOSI +00000000 W _ZN14HardwareSerialC1Ev +00000000 W _ZN14HardwareSerialC2Ev +00000000 n _ZN14HardwareSerialC5Ev + U _ZN5Print5writeEPKc + U _ZN5Print5writeEPKhj +00000000 W _ZN5PrintC1Ev +00000000 W _ZN5PrintC2Ev +00000000 n _ZN5PrintC5Ev +00000000 W _ZN6StreamC1Ev +00000000 W _ZN6StreamC2Ev +00000000 n _ZN6StreamC5Ev +00000000 T _ZN9UARTClass10IrqHandlerEv +00000000 T _ZN9UARTClass3endEv +00000000 T _ZN9UARTClass4peekEv +00000000 T _ZN9UARTClass4readEv +00000000 T _ZN9UARTClass5beginEm +00000000 T _ZN9UARTClass5flushEv +00000000 T _ZN9UARTClass5writeEh +00000000 T _ZN9UARTClass9availableEv +00000000 T _ZN9UARTClassC1EP12_ring_bufferS1_P4Uart4IRQnm +00000000 T _ZN9UARTClassC2EP12_ring_bufferS1_P4Uart4IRQnm +00000000 V _ZTI14HardwareSerial + U _ZTI5Print +00000000 V _ZTI6Stream +0000002c R _ZTI9UARTClass +00000000 V _ZTS14HardwareSerial +00000000 V _ZTS6Stream +00000038 R _ZTS9UARTClass +00000000 V _ZTV14HardwareSerial + U _ZTV5Print +00000000 V _ZTV6Stream +00000000 R _ZTV9UARTClass + U _ZTVN10__cxxabiv120__si_class_type_infoE + U __aeabi_unwind_cpp_pr1 + U __cxa_pure_virtual + +USART.o: + U PMC_EnablePeripheral +0000004c r _ZL15APinDescription +00000045 r _ZL2SS +00000048 r _ZL3SCK +00000047 r _ZL4MISO +00000046 r _ZL4MOSI +00000000 T _ZN10USARTClass10IrqHandlerEv +00000000 T _ZN10USARTClass3endEv +00000000 T _ZN10USARTClass4peekEv +00000000 T _ZN10USARTClass4readEv +00000000 T _ZN10USARTClass5beginEm +00000000 T _ZN10USARTClass5flushEv +00000000 T _ZN10USARTClass5writeEh +00000000 T _ZN10USARTClass9availableEv +00000000 T _ZN10USARTClassC1EP12_ring_bufferS1_P5Usart4IRQnm +00000000 T _ZN10USARTClassC2EP12_ring_bufferS1_P5Usart4IRQnm +00000000 W _ZN14HardwareSerialC1Ev +00000000 W _ZN14HardwareSerialC2Ev +00000000 n _ZN14HardwareSerialC5Ev + U _ZN5Print5writeEPKc + U _ZN5Print5writeEPKhj +00000000 W _ZN5PrintC1Ev +00000000 W _ZN5PrintC2Ev +00000000 n _ZN5PrintC5Ev +00000000 W _ZN6StreamC1Ev +00000000 W _ZN6StreamC2Ev +00000000 n _ZN6StreamC5Ev +0000002c R _ZTI10USARTClass +00000000 V _ZTI14HardwareSerial + U _ZTI5Print +00000000 V _ZTI6Stream +00000038 R _ZTS10USARTClass +00000000 V _ZTS14HardwareSerial +00000000 V _ZTS6Stream +00000000 R _ZTV10USARTClass +00000000 V _ZTV14HardwareSerial + U _ZTV5Print +00000000 V _ZTV6Stream + U _ZTVN10__cxxabiv120__si_class_type_infoE + U __aeabi_unwind_cpp_pr1 + U __cxa_pure_virtual + +main.o: +00000004 r _ZL15APinDescription +00000000 r _ZL2SS +00000003 r _ZL3SCK +00000002 r _ZL4MISO +00000001 r _ZL4MOSI + U __aeabi_unwind_cpp_pr0 + U init + U loop +00000000 T main + U setup diff --git a/hardware/atmel/cores/sam/lib/arduino_sam3s_ek_gcc_rel.a b/hardware/atmel/cores/sam/lib/arduino_sam3s_ek_gcc_rel.a new file mode 100644 index 0000000000000000000000000000000000000000..2f369c2f3528576aaa1646848d95a7a3e3724ab7 GIT binary patch literal 36314 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 literal 0 HcmV?d00001 diff --git a/hardware/atmel/cores/sam/lib/arduino_sam3s_ek_gcc_rel.a.txt b/hardware/atmel/cores/sam/lib/arduino_sam3s_ek_gcc_rel.a.txt new file mode 100644 index 000000000..819e5ef38 --- /dev/null +++ b/hardware/atmel/cores/sam/lib/arduino_sam3s_ek_gcc_rel.a.txt @@ -0,0 +1,135 @@ + +WInterrupts.o: +00000000 T attachInterrupt +00000000 T detachInterrupt +00000000 b intFunc + +wiring.o: + U GetTickCount + U LowLevelInit + U PIO_Configure +00000000 T SysTick_Handler + U TimeTick_Increment + U WDT_Disable +00000000 T Wait +00000000 T delayMicroseconds +00000000 T init +00000000 T micros +00000000 T millis +00000004 B timer0_millis +00000000 B timer0_overflow_count + +wiring_shift.o: + U digitalRead + U digitalWrite +00000000 T shiftIn +00000000 T shiftOut + +HardwareSerial.o: + +Print.o: +00000000 T _ZN5Print10printFloatEdh +00000000 T _ZN5Print11printNumberEmh +00000000 T _ZN5Print5printEPKc +00000000 T _ZN5Print5printERK6String +00000000 T _ZN5Print5printEc +00000000 T _ZN5Print5printEdi +00000000 T _ZN5Print5printEhi +00000000 T _ZN5Print5printEii +00000000 T _ZN5Print5printEji +00000000 T _ZN5Print5printEli +00000000 T _ZN5Print5printEmi +00000000 T _ZN5Print5writeEPKc +00000000 T _ZN5Print5writeEPKhj +00000000 T _ZN5Print7printlnEPKc +00000000 T _ZN5Print7printlnERK6String +00000000 T _ZN5Print7printlnEc +00000000 T _ZN5Print7printlnEdi +00000000 T _ZN5Print7printlnEhi +00000000 T _ZN5Print7printlnEii +00000000 T _ZN5Print7printlnEji +00000000 T _ZN5Print7printlnEli +00000000 T _ZN5Print7printlnEmi +00000000 T _ZN5Print7printlnEv + U _ZNK6StringixEj +0000001c R _ZTI5Print +00000014 R _ZTS5Print +00000000 R _ZTV5Print + U _ZTVN10__cxxabiv117__class_type_infoE + U __aeabi_d2iz + U __aeabi_d2uiz + U __aeabi_dadd + U __aeabi_dcmplt + U __aeabi_ddiv + U __aeabi_dmul + U __aeabi_dsub + U __aeabi_i2d + U __aeabi_ui2d + U __aeabi_unwind_cpp_pr0 + U __aeabi_unwind_cpp_pr1 + U __cxa_pure_virtual + +UART.o: + U PMC_DisablePeripheral + U PMC_EnablePeripheral + U _ZN5Print5writeEPKc + U _ZN5Print5writeEPKhj +00000000 T _ZN9UARTClass10IrqHandlerEv +00000000 T _ZN9UARTClass3endEv +00000000 T _ZN9UARTClass4peekEv +00000000 T _ZN9UARTClass4readEv +00000000 T _ZN9UARTClass5beginEm +00000000 T _ZN9UARTClass5flushEv +00000000 T _ZN9UARTClass5writeEh +00000000 T _ZN9UARTClass9availableEv +00000000 T _ZN9UARTClassC1EP12_ring_bufferS1_P4Uart4IRQnm +00000000 T _ZN9UARTClassC2EP12_ring_bufferS1_P4Uart4IRQnm +00000000 V _ZTI14HardwareSerial + U _ZTI5Print +00000000 V _ZTI6Stream +00000038 R _ZTI9UARTClass +00000000 V _ZTS14HardwareSerial +00000000 V _ZTS6Stream +0000002c R _ZTS9UARTClass +00000000 V _ZTV14HardwareSerial +00000000 V _ZTV6Stream +00000000 R _ZTV9UARTClass + U _ZTVN10__cxxabiv120__si_class_type_infoE + U __aeabi_unwind_cpp_pr0 + U __aeabi_unwind_cpp_pr1 + U __cxa_pure_virtual + +USART.o: + U PMC_EnablePeripheral +00000000 T _ZN10USARTClass10IrqHandlerEv +00000000 T _ZN10USARTClass3endEv +00000000 T _ZN10USARTClass4peekEv +00000000 T _ZN10USARTClass4readEv +00000000 T _ZN10USARTClass5beginEm +00000000 T _ZN10USARTClass5flushEv +00000000 T _ZN10USARTClass5writeEh +00000000 T _ZN10USARTClass9availableEv +00000000 T _ZN10USARTClassC1EP12_ring_bufferS1_P5Usart4IRQnm +00000000 T _ZN10USARTClassC2EP12_ring_bufferS1_P5Usart4IRQnm + U _ZN5Print5writeEPKc + U _ZN5Print5writeEPKhj +0000003c R _ZTI10USARTClass +00000000 V _ZTI14HardwareSerial + U _ZTI5Print +00000000 V _ZTI6Stream +0000002c R _ZTS10USARTClass +00000000 V _ZTS14HardwareSerial +00000000 V _ZTS6Stream +00000000 R _ZTV10USARTClass +00000000 V _ZTV14HardwareSerial +00000000 V _ZTV6Stream + U _ZTVN10__cxxabiv120__si_class_type_infoE + U __aeabi_unwind_cpp_pr0 + U __cxa_pure_virtual + +main.o: + U __aeabi_unwind_cpp_pr1 + U init + U loop +00000000 T main + U setup diff --git a/hardware/atmel/cores/sam/main.cpp b/hardware/atmel/cores/sam/main.cpp new file mode 100644 index 000000000..64db00f70 --- /dev/null +++ b/hardware/atmel/cores/sam/main.cpp @@ -0,0 +1,15 @@ +#define ARDUINO_MAIN +#include "Arduino.h" + +int main(void) +{ + init(); + + setup(); + + for (;;) + loop(); + + return 0; +} + diff --git a/hardware/atmel/cores/sam/sam3s_ek/pins_arduino.h b/hardware/atmel/cores/sam/sam3s_ek/pins_arduino.h new file mode 100644 index 000000000..29a1379ef --- /dev/null +++ b/hardware/atmel/cores/sam/sam3s_ek/pins_arduino.h @@ -0,0 +1,146 @@ +#ifndef Pins_Arduino_h +#define Pins_Arduino_h + +//#ifdef ARDUINO_MAIN + +#define PIN_LED_BLUE (0u) +#define PIN_LED_GREEN (1u) +#define PIN_LED_RED (2u) +#define PIN_LED PIN_LED_BLUE + +const static uint8_t SS = 34 ; +const static uint8_t MOSI = 32 ; +const static uint8_t MISO = 31 ; +const static uint8_t SCK = 33 ; + +#define PINS_UART (16u) + +/* Types used for the tables below */ +typedef struct _PinDescription +{ + Pio* pPort ; + uint32_t dwPin ; + uint32_t dwPeripheralId ; + EPioType dwPinType ; + uint32_t dwPinAttribute ; +} PinDescription ; + +static const PinDescription APinDescription[]= +{ + // LEDS, 0..2 +#ifdef BOARD_REV_A + { PIOC, PIO_PC20, ID_PIOC, PIO_OUTPUT_1, PIO_DEFAULT }, // LED BLUE + { PIOC, PIO_PC21, ID_PIOC, PIO_OUTPUT_1, PIO_DEFAULT }, // LED GREEN + { PIOC, PIO_PC22, ID_PIOC, PIO_OUTPUT_1, PIO_DEFAULT }, // LED RED +#endif +#ifdef BOARD_REV_B + { PIOA, PIO_PA19, ID_PIOA, PIO_OUTPUT_1, PIO_DEFAULT }, // LED BLUE + { PIOA, PIO_PA20, ID_PIOA, PIO_OUTPUT_1, PIO_DEFAULT }, // LED GREEN + { PIOC, PIO_PC20, ID_PIOC, PIO_OUTPUT_1, PIO_DEFAULT }, // LED RED +#endif + + // Clock 32KHz, 3..4 + { PIOA, PIO_PA7, ID_PIOA, PIO_NOT_A_PIN, PIO_DEFAULT }, // XIN32 + { PIOA, PIO_PA8, ID_PIOA, PIO_NOT_A_PIN, PIO_DEFAULT }, // XOUT32 + + // Clock 12MHz, 5..6 + { PIOB, PIO_PB9, ID_PIOB, PIO_NOT_A_PIN, PIO_DEFAULT }, // XIN + { PIOB, PIO_PB8, ID_PIOB, PIO_NOT_A_PIN, PIO_DEFAULT }, // XOUT + + // JTAG, 7..10 + { PIOB, PIO_PB4, ID_PIOB, PIO_NOT_A_PIN, PIO_DEFAULT }, // TDI + { PIOB, PIO_PB5, ID_PIOB, PIO_NOT_A_PIN, PIO_DEFAULT }, // TDO + { PIOB, PIO_PB6, ID_PIOB, PIO_NOT_A_PIN, PIO_DEFAULT }, // TMS + { PIOB, PIO_PB7, ID_PIOB, PIO_NOT_A_PIN, PIO_DEFAULT }, // TCK + + // USB, 11..13 + { PIOB, PIO_PB10, ID_PIOB, PIO_NOT_A_PIN, PIO_DEFAULT }, // DDM + { PIOB, PIO_PB11, ID_PIOB, PIO_NOT_A_PIN, PIO_DEFAULT }, // DDP +#ifdef BOARD_REV_A + { PIOC, PIO_PC23, ID_PIOC, PIO_INPUT, PIO_PULLUP }, // USB_VBUS +#endif +#ifdef BOARD_REV_B + { PIOC, PIO_PC21, ID_PIOC, PIO_INPUT, PIO_PULLUP }, // USB_VBUS +#endif + + // UART0 (Serial), 14..16 + { PIOA, PIO_PA9, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT }, // URXD0 + { PIOA, PIO_PA10, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT }, // UTXD0 + { PIOA, PIO_PA9|PIO_PA10, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT }, // All UART0 pins + + // Push buttons, 17..18 + { PIOB, PIO_PB3, ID_PIOB, PIO_INPUT, PIO_PULLUP | PIO_DEBOUNCE | PIO_IT_RISE_EDGE }, // PB1 + { PIOC, PIO_PC12, ID_PIOC, PIO_INPUT, PIO_PULLUP | PIO_DEBOUNCE | PIO_IT_FALL_EDGE }, // PB2 + + // QTouch Slider, 19..20 + { PIOA, (PIO_PA0 | PIO_PA2 | PIO_PA4), ID_PIOA, PIO_INPUT, PIO_DEFAULT }, // QTSLIDR SNS + { PIOA, (PIO_PA1 | PIO_PA3 | PIO_PA5), ID_PIOA, PIO_INPUT, PIO_DEFAULT }, // QTSLIDR SNSK + + // QTouch Buttons, 21..22 + { PIOC, (PIO_PC22 | PIO_PC24 | PIO_PC26 | PIO_PC28 | PIO_PC30), ID_PIOC, PIO_INPUT, PIO_DEFAULT }, // KEYS SNS + { PIOC, (PIO_PC23 | PIO_PC25 | PIO_PC27 | PIO_PC29 | PIO_PC31), ID_PIOC, PIO_INPUT, PIO_DEFAULT }, // KEYS SNSK + + // MCI (SDCARD), 23..30 +#ifdef BOARD_REV_A + { PIOA, PIO_PA15, ID_PIOA, PIO_INPUT, PIO_PULLUP }, // MCI Card Detect +#endif +#ifdef BOARD_REV_B + { PIOA, PIO_PA6, ID_PIOA, PIO_INPUT, PIO_PULLUP }, // MCI Card Detect +#endif + { PIOA, PIO_PA30, ID_PIOA, PIO_PERIPH_C, PIO_PULLUP }, // MCDA0 + { PIOA, PIO_PA31, ID_PIOA, PIO_PERIPH_C, PIO_PULLUP }, // MCDA1 + { PIOA, PIO_PA26, ID_PIOA, PIO_PERIPH_C, PIO_PULLUP }, // MCDA2 + { PIOA, PIO_PA27, ID_PIOA, PIO_PERIPH_C, PIO_PULLUP }, // MCDA3 + { PIOA, PIO_PA28, ID_PIOA, PIO_PERIPH_C, PIO_PULLUP }, // MCCDA + { PIOA, PIO_PA29, ID_PIOA, PIO_PERIPH_C, PIO_PULLUP }, // MCCK + + { PIOA, PIO_PA26|PIO_PA27|PIO_PA28|PIO_PA29|PIO_PA30|PIO_PA31, ID_PIOA, PIO_PERIPH_C, PIO_PULLUP }, // All MCI Pins + + // SPI, 31..34 + { PIOA, PIO_PA12A_MISO, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT }, // MISO + { PIOA, PIO_PA13A_MOSI, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT }, // MOSI + { PIOA, PIO_PA14A_SPCK, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT }, // SPCK + { PIOA, PIO_PA11A_NPCS0, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT }, // NPCS0 + + // TouchScreen, 35..36 +#ifdef BOARD_REV_A + { PIOA, PIO_PA4, ID_PIOA, PIO_INPUT, PIO_PULLUP }, // IRQ_TSC + { PIOA, PIO_PA5, ID_PIOA, PIO_INPUT, PIO_PULLUP }, // BUSY_TSC +#endif +#ifdef BOARD_REV_B + { PIOA, PIO_PA16, ID_PIOA, PIO_INPUT, PIO_PULLUP }, // IRQ_TSC + { PIOA, PIO_PA17, ID_PIOA, PIO_INPUT, PIO_PULLUP }, // BUSY_TSC +#endif + + // USART1, 37..41 + { PIOA, PIO_PA21A_RXD1, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT }, // RXD1 + { PIOA, PIO_PA22A_TXD1, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT }, // TXD1 + { PIOA, PIO_PA24A_RTS1, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT }, // RTS1 + { PIOA, PIO_PA25A_CTS1, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT }, // CTS1 + { PIOA, PIO_PA23A_SCK1, ID_PIOA, PIO_OUTPUT_0, PIO_DEFAULT }, // COM1 ENABLE (MAX232) + + // LCD, 42..47 + { PIOC, 0xFF, ID_PIOC, PIO_PERIPH_A, PIO_PULLUP }, // EBI Data bus + { PIOC, PIO_PC8, ID_PIOC, PIO_PERIPH_A, PIO_PULLUP }, // EBI_NWE + { PIOC, PIO_PC11, ID_PIOC, PIO_PERIPH_A, PIO_PULLUP }, // EBI_NRD + { PIOC, PIO_PC15, ID_PIOC, PIO_PERIPH_A, PIO_PULLUP }, // LCD CS + { PIOC, PIO_PC19, ID_PIOC, PIO_PERIPH_A, PIO_PULLUP }, // LCD RS + { PIOC, PIO_PC13, ID_PIOC, PIO_OUTPUT_0, PIO_DEFAULT }, // LCD BackLight + + { NULL, 0, 0, PIO_NOT_A_PIN, PIO_DEFAULT } // END +} ; + +#ifdef BOARD_REV_A +# define PIN_TSC_IRQ_WUP_ID (1UL << 3) +#endif +#ifdef BOARD_REV_B +# define PIN_TSC_IRQ_WUP_ID (1UL << 15) +#endif + +#define BOARD_LCD_PINS PIN_EBI_DATA_BUS, PIN_EBI_NRD, PIN_EBI_NWE, PIN_EBI_NCS1, PIN_EBI_LCD_RS +#define BOARD_LCD_BASE 0x61000000 /** Define ILI9325 base address. */ +#define BOARD_LCD_RS (1 << 1) /** Define ILI9325 register select signal. */ + +//#endif // ARDUINO_MAIN + +#endif // Pins_Arduino_h \ No newline at end of file diff --git a/hardware/atmel/cores/sam/sam3s_ek/sam3s-ek.cpp b/hardware/atmel/cores/sam/sam3s_ek/sam3s-ek.cpp new file mode 100644 index 000000000..5107af281 --- /dev/null +++ b/hardware/atmel/cores/sam/sam3s_ek/sam3s-ek.cpp @@ -0,0 +1,51 @@ + +/* + * UART objects + */ +ring_buffer rx_buffer0 = { { 0 }, 0, 0 } ; +ring_buffer tx_buffer0 = { { 0 }, 0, 0 } ; +ring_buffer rx_buffer1 = { { 0 }, 0, 0 } ; +ring_buffer tx_buffer1 = { { 0 }, 0, 0 } ; + +UARTClass Serial( &rx_buffer0, &tx_buffer0, UART0, UART0_IRQn, ID_UART0 ) ; +UARTClass UART1( &rx_buffer1, &tx_buffer1, UART1, UART1_IRQn, ID_UART1 ) ; + +// IT handlers +extern void UART0_IrqHandler( void ) +{ + Serial.IrqHandler() ; +} + +extern void UART1_IrqHandler( void ) +{ + UART1.IrqHandler() ; +} + + +// ---------------------------------------------------------------------------- + + +/* + * USART objects + */ +ring_buffer rx_buffer2 = { { 0 }, 0, 0 } ; +ring_buffer tx_buffer2 = { { 0 }, 0, 0 } ; +ring_buffer rx_buffer3 = { { 0 }, 0, 0 } ; +ring_buffer tx_buffer3 = { { 0 }, 0, 0 } ; + +USARTClass USART1( &rx_buffer2, &tx_buffer2, USART0, USART0_IRQn, ID_USART0 ) ; +USARTClass USART2( &rx_buffer3, &tx_buffer3, USART1, USART1_IRQn, ID_USART1 ) ; + +// IT handlers +extern void USART0_IrqHandler( void ) +{ + USART0.IrqHandler() ; +} + +extern void USART1_IrqHandler( void ) +{ + USART1.IrqHandler() ; +} + +// ---------------------------------------------------------------------------- + diff --git a/hardware/atmel/cores/sam/sam3s_ek/sam3s-ek.h b/hardware/atmel/cores/sam/sam3s_ek/sam3s-ek.h new file mode 100644 index 000000000..f879a32b2 --- /dev/null +++ b/hardware/atmel/cores/sam/sam3s_ek/sam3s-ek.h @@ -0,0 +1,13 @@ + +#include "Arduino.h" + +extern UARTClass Serial ; +extern UARTClass UART2 ; + +extern USARTClass USART1 ; +extern USARTClass USART2 ; + +#if defined(USBCON) + #include "usb_api.h" +#endif + diff --git a/hardware/atmel/cores/sam/sam3s_ek/sam3s_ek_flash.gdb b/hardware/atmel/cores/sam/sam3s_ek/sam3s_ek_flash.gdb new file mode 100644 index 000000000..7d7961577 --- /dev/null +++ b/hardware/atmel/cores/sam/sam3s_ek/sam3s_ek_flash.gdb @@ -0,0 +1,31 @@ +#******************************************************* +# +# Connect to J-Link and debug application in flash. +# + +# define 'reset' command +define reset + +# Connect to the J-Link gdb server +target remote localhost:2331 +# Reset the chip to get to a known state +monitor reset + +# Select flash device +monitor flash device = AT91SAM3S4C +# Enable flash download and flash breakpoints +monitor flash download = 1 +# Load the program +load + +# Reset peripheral (RSTC_CR) +set *0x400e1400 = 0xA5000004 + +# Initializing PC and stack pointer +mon reg sp=(0x400000) +set *0x400004 = *0x400004 & 0xFFFFFFFE +mon reg pc=(0x400004) +info reg + +# end of 'reset' command +end diff --git a/hardware/atmel/cores/sam/sam3s_ek/sam3s_ek_flash.ld b/hardware/atmel/cores/sam/sam3s_ek/sam3s_ek_flash.ld new file mode 100644 index 000000000..c47a2c508 --- /dev/null +++ b/hardware/atmel/cores/sam/sam3s_ek/sam3s_ek_flash.ld @@ -0,0 +1,140 @@ +/* ---------------------------------------------------------------------------- + * ATMEL Microcontroller Software Support + * ---------------------------------------------------------------------------- + * Copyright (c) 2009, Atmel Corporation + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the disclaimer below. + * + * Atmel's name may not be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * ---------------------------------------------------------------------------- + */ + +/*------------------------------------------------------------------------------ + * Linker script for running in internal FLASH on the ATSAM3S4 + *----------------------------------------------------------------------------*/ + +OUTPUT_FORMAT("elf32-littlearm", "elf32-littlearm", "elf32-littlearm") +OUTPUT_ARCH(arm) +SEARCH_DIR(.) + +/* Memory Spaces Definitions */ +MEMORY +{ + rom (rx) : ORIGIN = 0x00400000, LENGTH = 0x00040000 /* flash, 256K */ + ram (rwx) : ORIGIN = 0x20000000, LENGTH = 0x0000c000 /* sram, 48K */ +} + +/* Section Definitions */ +SECTIONS +{ + .text : + { + . = ALIGN(4); + _sfixed = .; + KEEP(*(.vectors .vectors.*)) + *(.text .text.* .gnu.linkonce.t.*) + *(.glue_7t) *(.glue_7) + *(.rodata .rodata* .gnu.linkonce.r.*) + *(.ARM.extab* .gnu.linkonce.armextab.*) + + /* Support C constructors, and C destructors in both user code + and the C library. This also provides support for C++ code. */ + . = ALIGN(4); + KEEP(*(.init)) + . = ALIGN(4); + __preinit_array_start = .; + KEEP (*(.preinit_array)) + __preinit_array_end = .; + + . = ALIGN(4); + __init_array_start = .; + KEEP (*(SORT(.init_array.*))) + KEEP (*(.init_array)) + __init_array_end = .; + + . = ALIGN(0x4); + KEEP (*crtbegin.o(.ctors)) + KEEP (*(EXCLUDE_FILE (*crtend.o) .ctors)) + KEEP (*(SORT(.ctors.*))) + KEEP (*crtend.o(.ctors)) + + . = ALIGN(4); + KEEP(*(.fini)) + + . = ALIGN(4); + __fini_array_start = .; + KEEP (*(.fini_array)) + KEEP (*(SORT(.fini_array.*))) + __fini_array_end = .; + + KEEP (*crtbegin.o(.dtors)) + KEEP (*(EXCLUDE_FILE (*crtend.o) .dtors)) + KEEP (*(SORT(.dtors.*))) + KEEP (*crtend.o(.dtors)) + + . = ALIGN(4); + _efixed = .; /* End of text section */ + } > rom + + /* .ARM.exidx is sorted, so has to go in its own output section. */ + PROVIDE_HIDDEN (__exidx_start = .); + .ARM.exidx : + { + *(.ARM.exidx* .gnu.linkonce.armexidx.*) + } > rom + PROVIDE_HIDDEN (__exidx_end = .); + + . = ALIGN(4); + _etext = .; + + .relocate : AT (_etext) + { + . = ALIGN(4); + _srelocate = .; + *(.ramfunc .ramfunc.*); + *(.data .data.*); + . = ALIGN(4); + _erelocate = .; + } > ram + + /* .bss section which is used for uninitialized data */ + .bss (NOLOAD) : + { + . = ALIGN(4); + _sbss = . ; + _szero = .; + *(.bss .bss.*) + *(COMMON) + . = ALIGN(4); + _ebss = . ; + _ezero = .; + } > ram + + /* stack section */ + .stack (NOLOAD): + { + . = ALIGN(8); + *(.stack .stack.*) + } > ram + + . = ALIGN(4); + _end = . ; +} diff --git a/hardware/atmel/cores/sam/sam3s_ek/sam3s_ek_sram.gdb b/hardware/atmel/cores/sam/sam3s_ek/sam3s_ek_sram.gdb new file mode 100644 index 000000000..019bd0a94 --- /dev/null +++ b/hardware/atmel/cores/sam/sam3s_ek/sam3s_ek_sram.gdb @@ -0,0 +1,27 @@ +#************************************************* +# +# Connect to J-Link and debug application in sram on SAM3S +# +# Note: +# First, users should modify Step1 and Step2 according to their project, +# then do Step3. + +# Step1: Connect to the J-Link gdb server +define reset +target remote localhost:2331 +monitor reset + +# Step2: Load file(eg. getting-started project) +load + +# Step3: Reset peripheral (RSTC_CR) +set *0x400e1400 = 0xA5000004 + +# Step4: Initializing PC and stack pointer +# Modify pc value to even before writing pc register +mon reg sp=(0x20000000) +set *0x20000004 = *0x20000004 & 0xFFFFFFFE +mon reg pc=(0x20000004) +info reg + +end diff --git a/hardware/atmel/cores/sam/sam3s_ek/sam3s_ek_sram.ld b/hardware/atmel/cores/sam/sam3s_ek/sam3s_ek_sram.ld new file mode 100644 index 000000000..9c6875554 --- /dev/null +++ b/hardware/atmel/cores/sam/sam3s_ek/sam3s_ek_sram.ld @@ -0,0 +1,140 @@ +/* ---------------------------------------------------------------------------- + * ATMEL Microcontroller Software Support + * ---------------------------------------------------------------------------- + * Copyright (c) 2009, Atmel Corporation + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the disclaimer below. + * + * Atmel's name may not be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE + * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * ---------------------------------------------------------------------------- + */ + +/*------------------------------------------------------------------------------ + * Linker script for running in internal SRAM on the ATSAM3S4 + *----------------------------------------------------------------------------*/ + +OUTPUT_FORMAT("elf32-littlearm", "elf32-littlearm", "elf32-littlearm") +OUTPUT_ARCH(arm) +SEARCH_DIR(.) + +/* Memory Spaces Definitions */ +MEMORY +{ + rom (rx) : ORIGIN = 0x00400000, LENGTH = 0x00040000 /* flash, 256K */ + ram (rwx) : ORIGIN = 0x20000000, LENGTH = 0x0000c000 /* sram, 48K */ +} + +/* Section Definitions */ +SECTIONS +{ + .text : + { + . = ALIGN(4); + _sfixed = .; + KEEP(*(.vectors .vectors.*)) + *(.text .text.* .gnu.linkonce.t.*) + *(.glue_7t) *(.glue_7) + *(.rodata .rodata* .gnu.linkonce.r.*) + *(.ARM.extab* .gnu.linkonce.armextab.*) + + /* Support C constructors, and C destructors in both user code + and the C library. This also provides support for C++ code. */ + . = ALIGN(4); + KEEP(*(.init)) + . = ALIGN(4); + __preinit_array_start = .; + KEEP (*(.preinit_array)) + __preinit_array_end = .; + + . = ALIGN(4); + __init_array_start = .; + KEEP (*(SORT(.init_array.*))) + KEEP (*(.init_array)) + __init_array_end = .; + + . = ALIGN(0x4); + KEEP (*crtbegin.o(.ctors)) + KEEP (*(EXCLUDE_FILE (*crtend.o) .ctors)) + KEEP (*(SORT(.ctors.*))) + KEEP (*crtend.o(.ctors)) + + . = ALIGN(4); + KEEP(*(.fini)) + + . = ALIGN(4); + __fini_array_start = .; + KEEP (*(.fini_array)) + KEEP (*(SORT(.fini_array.*))) + __fini_array_end = .; + + KEEP (*crtbegin.o(.dtors)) + KEEP (*(EXCLUDE_FILE (*crtend.o) .dtors)) + KEEP (*(SORT(.dtors.*))) + KEEP (*crtend.o(.dtors)) + + . = ALIGN(4); + _efixed = .; /* End of text section */ + } > ram + + . = ALIGN(4); + _etext = .; + + .relocate : AT (_etext) + { + . = ALIGN(4); + _srelocate = .; + *(.ramfunc .ramfunc.*); + *(.data .data.*); + . = ALIGN(4); + _erelocate = .; + } > ram + + /* .bss section which is used for uninitialized data */ + .bss (NOLOAD) : + { + . = ALIGN(4); + _sbss = . ; + _szero = .; + *(.bss .bss.*) + *(COMMON) + . = ALIGN(4); + _ebss = . ; + _ezero = .; + } > ram + + /* stack section */ + .stack (NOLOAD): + { + . = ALIGN(8); + *(.stack .stack.*) + } > ram + + /* .ARM.exidx is sorted, so has to go in its own output section. */ + PROVIDE_HIDDEN (__exidx_start = .); + .ARM.exidx : + { + *(.ARM.exidx* .gnu.linkonce.armexidx.*) + } > ram + PROVIDE_HIDDEN (__exidx_end = .); + + . = ALIGN(4); + _end = . ; +} diff --git a/hardware/atmel/cores/sam/validation/test.cpp b/hardware/atmel/cores/sam/validation/test.cpp new file mode 100644 index 000000000..18deb2412 --- /dev/null +++ b/hardware/atmel/cores/sam/validation/test.cpp @@ -0,0 +1,21 @@ + +void setup( void ) +{ + // initialize the digital pin as an output. + // Pin PIN_LED has an LED connected on most Arduino boards: + pinMode( PIN_LED, OUTPUT ) ; + + Serial.begin( 19200 ) ; +} + +void loop( void ) +{ + digitalWrite( PIN_LED, HIGH ) ; // set the LED on + delay( 1000 ) ; // wait for a second + digitalWrite( PIN_LED, LOW ) ; // set the LED off + delay( 1000 ) ; // wait for a second + + Serial.println( "test1" ) ; // send an initial string + delay( 1000 ) ; // wait for a second + Serial.println( "test2" ) ; // send an initial string +} diff --git a/hardware/atmel/cores/sam/wiring.c b/hardware/atmel/cores/sam/wiring.c new file mode 100644 index 000000000..9ac5938db --- /dev/null +++ b/hardware/atmel/cores/sam/wiring.c @@ -0,0 +1,142 @@ +/* + wiring.c - Partial implementation of the Wiring API for the ATmega8. + Part of Arduino - http://www.arduino.cc/ + + Copyright (c) 2005-2006 David A. Mellis + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General + Public License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place, Suite 330, + Boston, MA 02111-1307 USA + + $Id$ +*/ + +#include "wiring_private.h" + +// the prescaler is set so that timer0 ticks every 64 clock cycles, and the +// the overflow handler is called every 256 ticks. +#define MICROSECONDS_PER_TIMER0_OVERFLOW (clockCyclesToMicroseconds(64 * 256)) + +// the whole number of milliseconds per timer0 overflow +#define MILLIS_INC (MICROSECONDS_PER_TIMER0_OVERFLOW / 1000) + +// the fractional number of milliseconds per timer0 overflow. we shift right +// by three to fit these numbers into a byte. (for the clock speeds we care +// about - 8 and 16 MHz - this doesn't lose precision.) +#define FRACT_INC ((MICROSECONDS_PER_TIMER0_OVERFLOW % 1000) >> 3) +#define FRACT_MAX (1000 >> 3) + +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 + // (volatile variables must be read from memory on every access) + unsigned long m = timer0_millis; + unsigned char f = timer0_fract; + + m += MILLIS_INC; + f += FRACT_INC; + if (f >= FRACT_MAX) { + f -= FRACT_MAX; + m += 1; + } + + timer0_fract = f; + timer0_millis = m; + timer0_overflow_count++; +} +*/ + +uint32_t millis( void ) +{ +// todo: ensure no interrupts + return GetTickCount() ; +} + +unsigned long micros( void ) +{ +/* + 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++; +#else + if ((TIFR & _BV(TOV0)) && (t < 255)) + m++; +#endif + + SREG = oldSREG; + + return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond()); +*/ + return 0 ; +} + +void delay( uint32_t dwMs ) +{ + Wait( dwMs ) ; +} + +/* Delay for the given number of microseconds. Assumes a 64 MHz clock. */ +void delayMicroseconds(unsigned int us) +{ + unsigned long startMicros = micros(); + + while ((micros() - startMicros) < us) + { + //* do nothing + } +} + +/* + * Cortex-M3 Systick IT handler + */ +void SysTick_Handler( void ) +{ + // Increment tick count each ms + TimeTick_Increment() ; +} + +void init( void ) +{ + // Disable watchdog + WDT_Disable( WDT ) ; + + // Set Main clock to 64MHz using external 12MHz + LowLevelInit() ; + + // Set Systick to 1ms interval + SysTick_Config( BOARD_MCK/1000 ) ; + + // Initialize Serial port UART0 + PIO_Configure( APinDescription[PINS_UART].pPort, APinDescription[PINS_UART].dwPinType, + APinDescription[PINS_UART].dwPin, APinDescription[PINS_UART].dwPinAttribute ) ; +} diff --git a/hardware/atmel/cores/sam/wiring_analog.c b/hardware/atmel/cores/sam/wiring_analog.c new file mode 100644 index 000000000..d248f4ce8 --- /dev/null +++ b/hardware/atmel/cores/sam/wiring_analog.c @@ -0,0 +1,259 @@ +/* + wiring_analog.c - analog input and output + Part of Arduino - http://www.arduino.cc/ + + Copyright (c) 2005-2006 David A. Mellis + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General + Public License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place, Suite 330, + Boston, MA 02111-1307 USA + + Modified 28 September 2010 by Mark Sproul + + $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $ +*/ + +#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 + // will connect AVCC and the AREF pin, which would cause a short if + // there's something connected to AREF. + 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); +#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); + + // ADSC is cleared when the conversion finishes + while (bit_is_set(ADCSRA, ADSC)); + + // we have to read ADCL first; doing so locks both ADCL + // 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; +#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 + // that support it, as we turn it off when digitally reading or + // writing with them. Also, make sure the pin is in output mode + // for consistenty with Wiring, which doesn't require a pinMode + // call for the analog output pins. + pinMode(pin, OUTPUT); + if (val == 0) + { + digitalWrite(pin, LOW); + } + else if (val == 255) + { + digitalWrite(pin, HIGH); + } + else + { + switch(digitalPinToTimer(pin)) + { + // XXX fix needed for atmega8 + #if defined(TCCR0) && defined(COM00) && !defined(__AVR_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 + 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 + + #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); + } + } + } +} diff --git a/hardware/atmel/cores/sam/wiring_digital.c b/hardware/atmel/cores/sam/wiring_digital.c new file mode 100644 index 000000000..dd1b94979 --- /dev/null +++ b/hardware/atmel/cores/sam/wiring_digital.c @@ -0,0 +1,165 @@ +/* + wiring_digital.c - digital input and output functions + Part of Arduino - http://www.arduino.cc/ + + Copyright (c) 2005-2006 David A. Mellis + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General + Public License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place, Suite 330, + Boston, MA 02111-1307 USA + + Modified 28 September 2010 by Mark Sproul + + $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $ +*/ + +#include "wiring_private.h" +#include "pins_arduino.h" + +void pinMode(uint8_t pin, uint8_t mode) +{ + uint8_t bit = digitalPinToBitMask(pin); + uint8_t port = digitalPinToPort(pin); + volatile uint8_t *reg; + + if (port == NOT_A_PIN) return; + + // JWS: can I let the optimizer do this? + reg = portModeRegister(port); + + if (mode == INPUT) { + uint8_t oldSREG = SREG; + cli(); + *reg &= ~bit; + SREG = oldSREG; + } else { + uint8_t oldSREG = SREG; + cli(); + *reg |= bit; + SREG = oldSREG; + } +} + +// 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.) +// +// But shouldn't this be moved into pinMode? Seems silly to check and do on +// each digitalread or write. +// +// Mark Sproul: +// - Removed inline. Save 170 bytes on atmega1280 +// - changed to a switch statment; added 32 bytes but much easier to read and maintain. +// - Added more #ifdefs, now compiles for atmega645 +// +//static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline)); +//static inline void turnOffPWM(uint8_t timer) +static void turnOffPWM(uint8_t timer) +{ + 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(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(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 + } +} + +void digitalWrite(uint8_t pin, uint8_t val) +{ + uint8_t timer = digitalPinToTimer(pin); + uint8_t bit = digitalPinToBitMask(pin); + uint8_t port = digitalPinToPort(pin); + volatile uint8_t *out; + + if (port == NOT_A_PIN) return; + + // If the pin that support PWM output, we need to turn it off + // before doing a digital write. + if (timer != NOT_ON_TIMER) turnOffPWM(timer); + + out = portOutputRegister(port); + + uint8_t oldSREG = SREG; + cli(); + + if (val == LOW) { + *out &= ~bit; + } else { + *out |= bit; + } + + SREG = oldSREG; +} + +int digitalRead(uint8_t pin) +{ + uint8_t timer = digitalPinToTimer(pin); + uint8_t bit = digitalPinToBitMask(pin); + uint8_t port = digitalPinToPort(pin); + + if (port == NOT_A_PIN) return LOW; + + // If the pin that support PWM output, we need to turn it off + // before getting a digital reading. + if (timer != NOT_ON_TIMER) turnOffPWM(timer); + + if (*portInputRegister(port) & bit) return HIGH; + return LOW; +} diff --git a/hardware/atmel/cores/sam/wiring_private.h b/hardware/atmel/cores/sam/wiring_private.h new file mode 100644 index 000000000..b1743c231 --- /dev/null +++ b/hardware/atmel/cores/sam/wiring_private.h @@ -0,0 +1,43 @@ +/* + wiring_private.h - Internal header file. + Part of Arduino - http://www.arduino.cc/ + + Copyright (c) 2005-2006 David A. Mellis + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General + Public License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place, Suite 330, + Boston, MA 02111-1307 USA + + $Id: wiring.h 239 2007-01-12 17:58:39Z mellis $ +*/ + +#ifndef WiringPrivate_h +#define WiringPrivate_h + +#include +#include + +#include "Arduino.h" + +#ifdef __cplusplus +extern "C"{ +#endif + +typedef void (*voidFuncPtr)( void ) ; + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif diff --git a/hardware/atmel/cores/sam/wiring_pulse.c b/hardware/atmel/cores/sam/wiring_pulse.c new file mode 100644 index 000000000..0d968865d --- /dev/null +++ b/hardware/atmel/cores/sam/wiring_pulse.c @@ -0,0 +1,69 @@ +/* + wiring_pulse.c - pulseIn() function + Part of Arduino - http://www.arduino.cc/ + + Copyright (c) 2005-2006 David A. Mellis + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General + Public License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place, Suite 330, + Boston, MA 02111-1307 USA + + $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $ +*/ + +#include "wiring_private.h" +#include "pins_arduino.h" + +/* Measures the length (in microseconds) of a pulse on the pin; state is HIGH + * or LOW, the type of pulse to measure. Works on pulses from 2-3 microseconds + * to 3 minutes in length, but must be called at least a few dozen microseconds + * before the start of the pulse. */ +unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout) +{ + // cache the port and bit of the pin in order to speed up the + // pulse width measuring loop and achieve finer resolution. calling + // digitalRead() instead yields much coarser resolution. + uint8_t bit = digitalPinToBitMask(pin); + uint8_t port = digitalPinToPort(pin); + uint8_t stateMask = (state ? bit : 0); + unsigned long width = 0; // keep initialization out of time critical area + + // convert the timeout from microseconds to a number of times through + // the initial loop; it takes 16 clock cycles per iteration. + unsigned long numloops = 0; + unsigned long maxloops = microsecondsToClockCycles(timeout) / 16; + + // wait for any previous pulse to end + while ((*portInputRegister(port) & bit) == stateMask) + if (numloops++ == maxloops) + return 0; + + // wait for the pulse to start + while ((*portInputRegister(port) & bit) != stateMask) + if (numloops++ == maxloops) + return 0; + + // wait for the pulse to stop + while ((*portInputRegister(port) & bit) == stateMask) { + if (numloops++ == maxloops) + return 0; + width++; + } + + // convert the reading to microseconds. The loop has been determined + // to be 20 clock cycles long and have about 16 clocks between the edge + // and the start of the loop. There will be some error introduced by + // the interrupt handlers. + return clockCyclesToMicroseconds(width * 21 + 16); +} diff --git a/hardware/atmel/cores/sam/wiring_shift.c b/hardware/atmel/cores/sam/wiring_shift.c new file mode 100644 index 000000000..cfe786758 --- /dev/null +++ b/hardware/atmel/cores/sam/wiring_shift.c @@ -0,0 +1,55 @@ +/* + wiring_shift.c - shiftOut() function + Part of Arduino - http://www.arduino.cc/ + + Copyright (c) 2005-2006 David A. Mellis + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General + Public License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place, Suite 330, + Boston, MA 02111-1307 USA + + $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $ +*/ + +#include "wiring_private.h" + +uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder) { + uint8_t value = 0; + uint8_t i; + + for (i = 0; i < 8; ++i) { + digitalWrite(clockPin, HIGH); + if (bitOrder == LSBFIRST) + value |= digitalRead(dataPin) << i; + else + value |= digitalRead(dataPin) << (7 - i); + digitalWrite(clockPin, LOW); + } + return value; +} + +void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val) +{ + uint8_t i; + + for (i = 0; i < 8; i++) { + if (bitOrder == LSBFIRST) + digitalWrite(dataPin, !!(val & (1 << i))); + else + digitalWrite(dataPin, !!(val & (1 << (7 - i)))); + + digitalWrite(clockPin, HIGH); + digitalWrite(clockPin, LOW); + } +} diff --git a/hardware/atmel/programmers.txt b/hardware/atmel/programmers.txt new file mode 100644 index 000000000..371e5ae82 --- /dev/null +++ b/hardware/atmel/programmers.txt @@ -0,0 +1,18 @@ +samba.name=SAM-BA +samba.communication=serial +samba.protocol=sam-ba +samba.speed=19200 + +sambausb.name=SAM-BA +sambausb.communication=usb +sambausb.protocol=sam-ba + +arduinosamba.name=Arduino as SAM-BA +arduinosamba.communication=serial +arduinosamba.protocol=sam-ba +arduinosamba.speed=19200 + +arduinosambausb.name=Arduino as SAM-BA USB +arduinosambausb.communication=usb +arduinosambausb.protocol=sam-ba +