merge libmaple docs ("leaflabs-docs") into ./docs

In the past, libample documentation was forked out of this repository
because the documentation had increased in scope. For the librambutan,
and the rambutan project in general, we will try to keep documentation
closer to the source code, so the librambutan-specific documentation
should live here. Other sections of leaflabs-docs will be culled in a
following commit.

This merge attempts to maintain history by using a subtree strategy.
Followed directions at:

    http://nuclearsquid.com/writings/subtree-merging-and-you/

Full history for files should be accessible using the "--follow" flag to
git log, eg:

    git log --follow docs/source/adc.rst

It should be possible to pull patches from leaflabs-docs with:

    git pull -s subtree leaflabs-docs master

... at least until the docs in this repository diverge significantly.

1 files changed, 275 insertions, 0 deletions

diff --git a/docs/source/arduino-compatibility.rst b/docs/source/arduino-compatibility.rst
new file mode 100644
index 0000000..f7d3210
--- /dev/null
+++ b/docs/source/arduino-compatibility.rst
@@ -0,0 +1,275 @@
+.. highlight:: cpp
+
+.. _arduino-compatibility:
+
+=============================
+ Maple-Arduino Compatibility
+=============================
+
+.. contents:: Contents
+   :local:
+
+Overview
+--------
+
+The biggest difference between the Maple and most Arduino boards is
+that the Maple uses a 32-bit ARM Cortex-M3 architecture chip, while
+the Arduinos have 8-bit Atmel AVR chips. The different instruction set
+means that machine code (which makes up executable binary programs) is
+incompatible between the two, and a different compiler (actually just
+a different version of `gcc <http://gcc.gnu.org/>`_) is required.
+
+The compiler for the regular Arduino IDE is the popular `avr-gcc
+<http://www.nongnu.org/avr-libc/>`_ package; the compiler for the
+Maple version of the IDE is CodeSourcery's edition of gcc for the ARM
+EABI target (:command:`arm-non-eabi-gcc`).  A (preliminary) reference
+on :ref:`using arm-none-eabi-gcc <arm-gcc>` is available.
+
+The bitwidth of the processor means that the Maple can process 32-bit
+operations (like adding or multiplying two 32-bit integers) in a
+single instruction, while an Arduino processor would have to split up
+large operations into several smaller ones. In a lot of cases 8-bit
+operations are plenty (integers 0-255, single characters of text,
+etc.), but if you're dealing with higher resolution data, the speed up
+could be significant.
+
+A trade-off is that code could be larger as well; program instructions
+and memory locations can be up to 32 bits each.  However, removal of
+extra instructions and fancy packing together of simple instructions
+means that programs aren't much larger (or are even smaller).
+
+Header Numbering and Incompatibilities
+--------------------------------------
+
+.. FIXME [Maple-specific values]
+
+The numbering of headers is different; on the Maple each GPIO has a
+unique number: 0, 1, 2, all the way up to 37 (actually, there are
+:ref:`a few more <lang-disabledebugports>`...). On the Arduino, the
+analog pins are numbered separately (A0-A5) from the digital pins (D0\
+-D13).
+
+The incompatible hardware differences are:
+
+* :ref:`I2C <i2c>` **port**: on most Arduinos, the |i2c| port is Analog
+  Input 4 (SDA) and Analog Input 5 (SCL); on the Maple, |i2c| port 1
+  is D5 (SCL) and D9 (SDA), and |i2c| port 2 is D29 (SCL) and D30
+  (SDA).
+
+  It should be possible to skywire, sacrificing signal quality (due to
+  increased capacitance). Alternatively, |i2c| can be bit-banged
+  reasonably well in software. This peripheral could potentially be
+  rerouted internally, but we haven't looked into it.
+
+* :ref:`PWM <pwm>` **on D10**: all the other standard Arduino PWM
+  headers have PWM functionality on the Maple (D2,D3,D6,D9,D11), but
+  not D10.
+
+* **No External Voltage Reference**: The Arduino has an AREF pin which
+  allows the use of an external ADC voltage reference; the Maple has
+  an extra GPIO pin (D14) with PWM capability in this spot, and does
+  not allow an external voltage reference to be configured.
+
+* **EEPROM**: the Maple does not have any internal EEPROM. This
+  functionality can be emulated with regular persistent flash memory,
+  or with an external EEPROM chip.
+
+* **ISP Programming**: the Maple does not use an ISP/ICSP bus for
+  debugging; it uses :ref:`JTAG <jtag>`.
+
+
+Software Language/Library Changes
+---------------------------------
+
+With :ref:`a few exceptions <language-missing-features>`, the entire
+Wiring/Arduino language is supported.  However, there are some subtle
+differences, most of which are improvements:
+
+* **32-bit integers**: many standard functions either expect or return
+  full 32-bit (4 byte) integer values instead of the regular 16-bit (2
+  byte) Arduino values.
+
+* **64-bit doubles**: The :ref:`double <lang-double>` type is a full
+  double-precision floating point type on the Maple; it is a
+  single-precision floating point value on the Arduino.
+
+* :ref:`pinMode() <lang-pinmode>` **types**: any :ref:`GPIO <gpio>`
+  (including analog pins) can be configured into one of the following
+  modes with a single call to ``pinMode()``: ``OUTPUT``,
+  ``OUTPUT_OPEN_DRAIN``, ``INPUT_FLOATING``, ``INPUT_PULLUP``,
+  ``INPUT_PULLDOWN``. Additionally, the PWM pins (labeled "PWM" on the
+  silkscreen) can be configured in ``PWM`` and ``PWM_OPEN_DRAIN``
+  modes, and the analog input pins (labeled "AIN") can be configured
+  in ``INPUT_ANALOG`` mode. See the :ref:`GPIO documentation <gpio>`
+  for more information.
+
+* :ref:`Serial port <lang-serial>` **syntax**: like the `Arduino Mega
+  <http://arduino.cc/en/Main/ArduinoBoardMega>`_, the Maple has
+  multiple :ref:`USART ports <lang-serial>`.  By default, ``Serial``
+  is not mapped to any of them.  Use ``Serial1`` through ``Serial3``
+  instead.
+
+* **16-bit** :ref:`PWM <pwm>`: Arduino boards support 8-bit PWM, which
+  means that calls to :ref:`analogWrite() <lang-analogwrite>` take
+  values between 0 (always off) and 255 (always on).  The Maple
+  supports 16-bit PWM, so the corresponding values should be between 0
+  (always off) and 65535 (always on).
+
+* **12-bit** :ref:`ADC <adc>`: Arduino boards support 10-bit ADC, which
+  means that calls to :ref:`analogRead() <lang-analogread>` will
+  return values between 0 and 1023.  The Maple supports 12-bit ADC, so
+  the same call will instead return values between 0 and 4095.
+
+Shield and Device Compatibility
+-------------------------------
+
+**Can't find your shield?** Check out the `Compatible Shields
+<http://wiki.leaflabs.com/index.php?title=Compatible_Shields>`_ page
+on our wiki.
+
+.. list-table::
+   :header-rows: 1
+
+   * - Shield/Device
+     - Compatible?
+     - Notes
+
+   * - Ethernet shield
+     - Yes!
+     - Tested; no library yet
+
+   * - WiFi Shield
+     - Yes!
+     - Tested; preliminary library support
+
+   * - MIDI shield
+     - Yes!
+     - Tested; no library yet
+
+   * - XBee shield
+     - Unknown
+     -
+
+   * - Bluetooth shield
+     - Unknown
+     - Some Bluetooth <-> UART boards have been tested and are known
+       to work.
+
+   * - Cellular shield
+     - Unknown
+     -
+
+Library Porting Status
+----------------------
+
+The state of currently ported Arduino libraries is the
+:ref:`libraries`.
+
+.. TODO Update as libraries are ported.
+
+.. list-table::
+   :header-rows: 1
+
+
+   * - Library
+     - Ported?
+     - Notes
+
+   * - Wire
+     - Preliminary
+     - In progress; see :ref:`library reference <libraries-wire>`.
+
+   * - LiquidCrystal
+     - **Yes**
+     - :ref:`Included since IDE 0.0.7 <libraries-liquid-crystal>`
+
+   * - Ethernet
+     - Not yet
+     - Planned
+
+   * - EEPROM
+     - (Unsupported) third-party emulation
+     - The Maple doesn't have EEPROM; it uses flash instead.  There is
+       an `EEPROM emulation library
+       <http://akb77.com/g/stm32/maple-eeprom-emulation-library/>`_ by
+       `x893 <http://akb77.com/g/>`_, but we haven't tested it.
+
+   * - Firmata
+     - Not yet
+     - Planned
+
+   * - Matrix
+     - Not yet
+     - Planned
+
+   * - Servo
+     - **Yes**
+     - :ref:`Included since IDE 0.0.9 <libraries-servo>`
+
+   * - SoftwareSerial
+     - Not yet
+     - Planned
+
+   * - Sprite
+     - Not yet
+     - Planned
+
+   * - Stepper
+     - Not yet
+     - Planned
+
+Sketch and Library Porting HOWTO
+--------------------------------
+
+In addition to the suggestions in this section, you may find many of
+the individual :ref:`language reference <language>` pages useful.  As
+appropriate, these have "Arduino Compatibility" sections; one good
+example is the :ref:`analogWrite() <lang-analogwrite-compatibility>`
+function.
+
+- Check the hardware and header differences above, and see if your
+  project or shield needs to be modified (eg, add 3.3V level
+  converters or reroute PWM to header D10).
+
+- Check for ported library functionality. We intend to port all of the
+  core and popular libraries (like Wire, Ethernet, and the LCD screen
+  driver), but this task is not yet finished. (:ref:`Patches are
+  welcome! <libmaple-contributing>`).
+
+- Check for peripheral conflicts; changing the configuration of timers
+  and bus speeds for a feature on one header may impact all the
+  features on that hardware "port".  For example, changing the timer
+  prescaler to do long PWM pulses could impact |i2c| communications on
+  nearby headers.
+
+- Rewrite any low-level code. This could potentially be very
+  difficult, but hopefully you've used the Arduino libraries to
+  abstract away the registers and other hardware-specific
+  details. Your sketch probably doesn't have any low-level code; a
+  library which wraps a particular peripheral very well may.  Some
+  help is available in the :ref:`arm-gcc` reference.
+
+- Redeclare variable sizes if necessary: generics like ``int`` will
+  probably work unless you depend on side-effects like rollover.
+
+- Check every ``pinMode()``: the Maple has more modes for GPIO
+  pins. For example, make sure to set analog pins to ``INPUT_ANALOG``
+  before reading and PWM pins to ``PWM`` before writing.  The full set
+  of pin modes is documented in the :ref:`lang-pinmode` reference.
+
+- Modify PWM writes: ``pinMode()`` must be set to ``PWM``, the
+  frequency of the PWM pulse configured, and the duty cycle written
+  with up to 16-bit resolution.
+
+- Modify ADC reads: :ref:`lang-analogread` takes the full pin number
+  (not 0-5) and returns a full 12-bit reading. The ADC pin must have
+  its ``pinMode()`` set to ``INPUT_ANALOG``.
+
+- Possibly convert all Serial-over-USB communications to use
+  :ref:`lang-serialusb` instead of a USART :ref:`serial port
+  <lang-serial>`. The Maple has a dedicated USB port which is not
+  connected to the USART TX/RX pins in any way.
+
+- Check timing: Maple clock cycles are just 13.9 nanoseconds, though
+  the peripheral bus speeds (which limit GPIO output) are clocked
+  slower.