Inital commit... halfway through the project

1 files changed, 335 insertions, 0 deletions

diff --git a/libraries/Firmata/Boards.h b/libraries/Firmata/Boards.h
new file mode 100644
index 0000000..85e7a78
--- /dev/null
+++ b/libraries/Firmata/Boards.h
@@ -0,0 +1,335 @@
+/* Boards.h - Hardware Abstraction Layer for Firmata library */

+

+#ifndef Firmata_Boards_h

+#define Firmata_Boards_h

+

+#include <WProgram.h>	// for digitalRead, digitalWrite, etc

+

+// Normally Servo.h must be included before Firmata.h (which then includes

+// this file).  If Servo.h wasn't included, this allows the code to still

+// compile, but without support for any Servos.  Hopefully that's what the

+// user intended by not including Servo.h

+#ifndef MAX_SERVOS

+#define MAX_SERVOS 0

+#endif

+

+/*

+    Firmata Hardware Abstraction Layer

+

+Firmata is built on top of the hardware abstraction functions of Arduino,

+specifically digitalWrite, digitalRead, analogWrite, analogRead, and 

+pinMode.  While these functions offer simple integer pin numbers, Firmata

+needs more information than is provided by Arduino.  This file provides

+all other hardware specific details.  To make Firmata support a new board,

+only this file should require editing.

+

+The key concept is every "pin" implemented by Firmata may be mapped to

+any pin as implemented by Arduino.  Usually a simple 1-to-1 mapping is

+best, but such mapping should not be assumed.  This hardware abstraction

+layer allows Firmata to implement any number of pins which map onto the

+Arduino implemented pins in almost any arbitrary way.

+

+

+General Constants:

+

+These constants provide basic information Firmata requires.

+

+TOTAL_PINS: The total number of pins Firmata implemented by Firmata.

+    Usually this will match the number of pins the Arduino functions

+    implement, including any pins pins capable of analog or digital.

+    However, Firmata may implement any number of pins.  For example,

+    on Arduino Mini with 8 analog inputs, 6 of these may be used

+    for digital functions, and 2 are analog only.  On such boards,

+    Firmata can implement more pins than Arduino's pinMode()

+    function, in order to accommodate those special pins.  The

+    Firmata protocol supports a maximum of 128 pins, so this

+    constant must not exceed 128.

+

+TOTAL_ANALOG_PINS: The total number of analog input pins implemented.

+    The Firmata protocol allows up to 16 analog inputs, accessed

+    using offsets 0 to 15.  Because Firmata presents the analog

+    inputs using different offsets than the actual pin numbers

+    (a legacy of Arduino's analogRead function, and the way the

+    analog input capable pins are physically labeled on all

+    Arduino boards), the total number of analog input signals

+    must be specified.  16 is the maximum.

+

+VERSION_BLINK_PIN: When Firmata starts up, it will blink the version

+    number.  This constant is the Arduino pin number where a

+    LED is connected.

+

+

+Pin Mapping Macros:

+

+These macros provide the mapping between pins as implemented by

+Firmata protocol and the actual pin numbers used by the Arduino

+functions.  Even though such mappings are often simple, pin

+numbers received by Firmata protocol should always be used as

+input to these macros, and the result of the macro should be

+used with with any Arduino function.

+

+When Firmata is extended to support a new pin mode or feature,

+a pair of macros should be added and used for all hardware

+access.  For simple 1:1 mapping, these macros add no actual

+overhead, yet their consistent use allows source code which

+uses them consistently to be easily adapted to all other boards

+with different requirements.

+

+IS_PIN_XXXX(pin): The IS_PIN macros resolve to true or non-zero

+    if a pin as implemented by Firmata corresponds to a pin

+    that actually implements the named feature.

+

+PIN_TO_XXXX(pin): The PIN_TO macros translate pin numbers as

+    implemented by Firmata to the pin numbers needed as inputs

+    to the Arduino functions.  The corresponding IS_PIN macro

+    should always be tested before using a PIN_TO macro, so

+    these macros only need to handle valid Firmata pin

+    numbers for the named feature.

+

+

+Port Access Inline Funtions:

+

+For efficiency, Firmata protocol provides access to digital

+input and output pins grouped by 8 bit ports.  When these

+groups of 8 correspond to actual 8 bit ports as implemented

+by the hardware, these inline functions can provide high

+speed direct port access.  Otherwise, a default implementation

+using 8 calls to digitalWrite or digitalRead is used.

+

+When porting Firmata to a new board, it is recommended to

+use the default functions first and focus only on the constants

+and macros above.  When those are working, if optimized port

+access is desired, these inline functions may be extended.

+The recommended approach defines a symbol indicating which

+optimization to use, and then conditional complication is

+used within these functions.

+

+readPort(port, bitmask):  Read an 8 bit port, returning the value.

+   port:    The port number, Firmata pins port*8 to port*8+7

+   bitmask: The actual pins to read, indicated by 1 bits.

+

+writePort(port, value, bitmask):  Write an 8 bit port.

+   port:    The port number, Firmata pins port*8 to port*8+7

+   value:   The 8 bit value to write

+   bitmask: The actual pins to write, indicated by 1 bits.

+*/

+

+/*==============================================================================

+ * Board Specific Configuration

+ *============================================================================*/

+

+// Arduino Duemilanove, Diecimila, and NG

+#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__)

+#define TOTAL_ANALOG_PINS       8

+#define TOTAL_PINS              24 // 14 digital + 2 unused + 8 analog

+#define VERSION_BLINK_PIN       13

+#define IS_PIN_DIGITAL(p)       (((p) >= 2 && (p) <= 13) || ((p) >= 16 && (p) <= 21))

+#define IS_PIN_ANALOG(p)        ((p) >= 16 && (p) <= 23)

+#define IS_PIN_PWM(p)           IS_PIN_DIGITAL(p)

+#define IS_PIN_SERVO(p)         ((p) >= 2 && (p) <= 13 && (p) - 2 < MAX_SERVOS)

+#define IS_PIN_I2C(p)           (0)

+#define PIN_TO_DIGITAL(p)       (((p) < 16) ? (p) : (p) - 2)

+#define PIN_TO_ANALOG(p)        ((p) - 16)

+#define PIN_TO_PWM(p)           PIN_TO_DIGITAL(p)

+#define PIN_TO_SERVO(p)         ((p) - 2)

+#define ARDUINO_PINOUT_OPTIMIZE 1

+

+

+// old Arduinos

+#elif defined(__AVR_ATmega8__)

+#define TOTAL_ANALOG_PINS       6

+#define TOTAL_PINS              22 // 14 digital + 2 unused + 6 analog

+#define VERSION_BLINK_PIN       13

+#define IS_PIN_DIGITAL(p)       (((p) >= 2 && (p) <= 13) || ((p) >= 16 && (p) <= 21))

+#define IS_PIN_ANALOG(p)        ((p) >= 16 && (p) <= 21)

+#define IS_PIN_PWM(p)           IS_PIN_DIGITAL(p)

+#define IS_PIN_SERVO(p)         ((p) >= 2 && (p) <= 13 && (p) - 2 < MAX_SERVOS)

+#define IS_PIN_I2C(p)           (0)

+#define PIN_TO_DIGITAL(p)       (((p) < 16) ? (p) : (p) - 2)

+#define PIN_TO_ANALOG(p)        ((p) - 16)

+#define PIN_TO_PWM(p)           PIN_TO_DIGITAL(p)

+#define PIN_TO_SERVO(p)         ((p) - 2)

+#define ARDUINO_PINOUT_OPTIMIZE 1

+

+

+// Arduino Mega

+#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)

+#define TOTAL_ANALOG_PINS       16

+#define TOTAL_PINS              70 // 54 digital + 16 analog

+#define VERSION_BLINK_PIN       13

+#define IS_PIN_DIGITAL(p)       ((p) >= 2 && (p) < TOTAL_PINS)

+#define IS_PIN_ANALOG(p)        ((p) >= 54 && (p) < TOTAL_PINS)

+#define IS_PIN_PWM(p)           IS_PIN_DIGITAL(p)

+#define IS_PIN_SERVO(p)         ((p) >= 2 && (p) - 2 < MAX_SERVOS)

+#define IS_PIN_I2C(p)           (0)

+#define PIN_TO_DIGITAL(p)       (p)

+#define PIN_TO_ANALOG(p)        ((p) - 54)

+#define PIN_TO_PWM(p)           PIN_TO_DIGITAL(p)

+#define PIN_TO_SERVO(p)         ((p) - 2)

+

+

+// Wiring

+#elif defined(__AVR_ATmega128__)

+#define TOTAL_ANALOG_PINS       8

+#define TOTAL_PINS              51

+#define VERSION_BLINK_PIN       48

+// TODO: hardware abstraction for wiring board

+

+

+// Teensy 1.0

+#elif defined(__AVR_AT90USB162__)

+#define TOTAL_ANALOG_PINS       0

+#define TOTAL_PINS              21 // 21 digital + no analog

+#define VERSION_BLINK_PIN       6

+#define IS_PIN_DIGITAL(p)       ((p) >= 0 && (p) < TOTAL_PINS)

+#define IS_PIN_ANALOG(p)        (0)

+#define IS_PIN_PWM(p)           IS_PIN_DIGITAL(p)

+#define IS_PIN_SERVO(p)         ((p) >= 0 && (p) < MAX_SERVOS)

+#define IS_PIN_I2C(p)           (0)

+#define PIN_TO_DIGITAL(p)       (p)

+#define PIN_TO_ANALOG(p)        (0)

+#define PIN_TO_PWM(p)           PIN_TO_DIGITAL(p)

+#define PIN_TO_SERVO(p)         (p)

+

+

+// Teensy 2.0

+#elif defined(__AVR_ATmega32U4__)

+#define TOTAL_ANALOG_PINS       12

+#define TOTAL_PINS              25 // 11 digital + 12 analog

+#define VERSION_BLINK_PIN       11

+#define IS_PIN_DIGITAL(p)       ((p) >= 0 && (p) < TOTAL_PINS)

+#define IS_PIN_ANALOG(p)        ((p) >= 11 && (p) <= 22)

+#define IS_PIN_PWM(p)           IS_PIN_DIGITAL(p)

+#define IS_PIN_SERVO(p)         ((p) >= 0 && (p) < MAX_SERVOS)

+#define IS_PIN_I2C(p)           (0)

+#define PIN_TO_DIGITAL(p)       (p)

+#define PIN_TO_ANALOG(p)        (((p)<22)?21-(p):11)

+#define PIN_TO_PWM(p)           PIN_TO_DIGITAL(p)

+#define PIN_TO_SERVO(p)         (p)

+

+

+// Teensy++ 1.0 and 2.0

+#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__)

+#define TOTAL_ANALOG_PINS       8

+#define TOTAL_PINS              46 // 38 digital + 8 analog

+#define VERSION_BLINK_PIN       6

+#define IS_PIN_DIGITAL(p)       ((p) >= 0 && (p) < TOTAL_PINS)

+#define IS_PIN_ANALOG(p)        ((p) >= 38 && (p) < TOTAL_PINS)

+#define IS_PIN_PWM(p)           IS_PIN_DIGITAL(p)

+#define IS_PIN_SERVO(p)         ((p) >= 0 && (p) < MAX_SERVOS)

+#define IS_PIN_I2C(p)           (0)

+#define PIN_TO_DIGITAL(p)       (p)

+#define PIN_TO_ANALOG(p)        ((p) - 38)

+#define PIN_TO_PWM(p)           PIN_TO_DIGITAL(p)

+#define PIN_TO_SERVO(p)         (p)

+

+

+// Sanguino

+#elif defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644__)

+#define TOTAL_ANALOG_PINS       8

+#define TOTAL_PINS              32 // 24 digital + 8 analog

+#define VERSION_BLINK_PIN       0

+#define IS_PIN_DIGITAL(p)       ((p) >= 2 && (p) < TOTAL_PINS)

+#define IS_PIN_ANALOG(p)        ((p) >= 24 && (p) < TOTAL_PINS)

+#define IS_PIN_PWM(p)           IS_PIN_DIGITAL(p)

+#define IS_PIN_SERVO(p)         ((p) >= 0 && (p) < MAX_SERVOS)

+#define IS_PIN_I2C(p)           (0)

+#define PIN_TO_DIGITAL(p)       (p)

+#define PIN_TO_ANALOG(p)        ((p) - 24)

+#define PIN_TO_PWM(p)           PIN_TO_DIGITAL(p)

+#define PIN_TO_SERVO(p)         ((p) - 2)

+

+

+// Illuminato

+#elif defined(__AVR_ATmega645__)

+#define TOTAL_ANALOG_PINS       6

+#define TOTAL_PINS              42 // 36 digital + 6 analog

+#define VERSION_BLINK_PIN       13

+#define IS_PIN_DIGITAL(p)       ((p) >= 2 && (p) < TOTAL_PINS)

+#define IS_PIN_ANALOG(p)        ((p) >= 36 && (p) < TOTAL_PINS)

+#define IS_PIN_PWM(p)           IS_PIN_DIGITAL(p)

+#define IS_PIN_SERVO(p)         ((p) >= 0 && (p) < MAX_SERVOS)

+#define IS_PIN_I2C(p)           (0)

+#define PIN_TO_DIGITAL(p)       (p)

+#define PIN_TO_ANALOG(p)        ((p) - 36)

+#define PIN_TO_PWM(p)           PIN_TO_DIGITAL(p)

+#define PIN_TO_SERVO(p)         ((p) - 2)

+

+

+// anything else

+#else

+#error "Please edit Boards.h with a hardware abstraction for this board"

+#endif

+

+

+/*==============================================================================

+ * readPort() - Read an 8 bit port

+ *============================================================================*/

+

+static inline unsigned char readPort(byte, byte) __attribute__((always_inline, unused));

+static inline unsigned char readPort(byte port, byte bitmask)

+{

+#if defined(ARDUINO_PINOUT_OPTIMIZE)

+	if (port == 0) return PIND & B11111100 & bitmask; // ignore Rx/Tx 0/1

+	if (port == 1) return PINB & B00111111 & bitmask; // pins 8-13 (14,15 are disabled for the crystal)

+	if (port == 2) return PINC & bitmask;

+	return 0;

+#else

+	unsigned char out=0, pin=port*8;

+	if (IS_PIN_DIGITAL(pin+0) && (bitmask & 0x01) && digitalRead(PIN_TO_DIGITAL(pin+0))) out |= 0x01;

+	if (IS_PIN_DIGITAL(pin+1) && (bitmask & 0x02) && digitalRead(PIN_TO_DIGITAL(pin+1))) out |= 0x02;

+	if (IS_PIN_DIGITAL(pin+2) && (bitmask & 0x04) && digitalRead(PIN_TO_DIGITAL(pin+2))) out |= 0x04;

+	if (IS_PIN_DIGITAL(pin+3) && (bitmask & 0x08) && digitalRead(PIN_TO_DIGITAL(pin+3))) out |= 0x08;

+	if (IS_PIN_DIGITAL(pin+4) && (bitmask & 0x10) && digitalRead(PIN_TO_DIGITAL(pin+4))) out |= 0x10;

+	if (IS_PIN_DIGITAL(pin+5) && (bitmask & 0x20) && digitalRead(PIN_TO_DIGITAL(pin+5))) out |= 0x20;

+	if (IS_PIN_DIGITAL(pin+6) && (bitmask & 0x40) && digitalRead(PIN_TO_DIGITAL(pin+6))) out |= 0x40;

+	if (IS_PIN_DIGITAL(pin+7) && (bitmask & 0x80) && digitalRead(PIN_TO_DIGITAL(pin+7))) out |= 0x80;

+	return out;

+#endif

+}

+

+/*==============================================================================

+ * writePort() - Write an 8 bit port, only touch pins specified by a bitmask

+ *============================================================================*/

+

+static inline unsigned char writePort(byte, byte, byte) __attribute__((always_inline, unused));

+static inline unsigned char writePort(byte port, byte value, byte bitmask)

+{

+#if defined(ARDUINO_PINOUT_OPTIMIZE)

+	if (port == 0) {

+		bitmask = bitmask & 0xFC;  // Tx & Rx pins

+		cli();

+		PORTD = (PORTD & ~bitmask) | (bitmask & value);

+		sei();

+	} else if (port == 1) {

+		cli();

+		PORTB = (PORTB & ~bitmask) | (bitmask & value);

+		sei();

+	} else if (port == 2) {

+		cli();

+		PORTC = (PORTC & ~bitmask) | (bitmask & value);

+		sei();

+	}

+#else

+	byte pin=port*8;

+	if ((bitmask & 0x01)) digitalWrite(PIN_TO_DIGITAL(pin+0), (value & 0x01));

+	if ((bitmask & 0x02)) digitalWrite(PIN_TO_DIGITAL(pin+1), (value & 0x02));

+	if ((bitmask & 0x04)) digitalWrite(PIN_TO_DIGITAL(pin+2), (value & 0x04));

+	if ((bitmask & 0x08)) digitalWrite(PIN_TO_DIGITAL(pin+3), (value & 0x08));

+	if ((bitmask & 0x10)) digitalWrite(PIN_TO_DIGITAL(pin+4), (value & 0x10));

+	if ((bitmask & 0x20)) digitalWrite(PIN_TO_DIGITAL(pin+5), (value & 0x20));

+	if ((bitmask & 0x40)) digitalWrite(PIN_TO_DIGITAL(pin+6), (value & 0x40));

+	if ((bitmask & 0x80)) digitalWrite(PIN_TO_DIGITAL(pin+7), (value & 0x80));

+#endif

+}

+

+

+

+

+#ifndef TOTAL_PORTS

+#define TOTAL_PORTS             ((TOTAL_PINS + 7) / 8)

+#endif

+

+

+#endif /* Firmata_Boards_h */

+