You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
336 lines
14 KiB
C
336 lines
14 KiB
C
/* 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 */
|
|
|