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) is required.
The compiler for the regular Arduino IDE is the popular avr-gcc package; the compiler for the Maple version of the IDE is CodeSourcery’s edition of gcc for the ARM EABI target (arm-none-eabi-gcc). A (preliminary) reference on using arm-none-eabi-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).
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 a few more...). On the Arduino, the analog pins are numbered separately (A0-A5) from the digital pins (D0-D13).
The incompatible hardware differences are:
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.
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 JTAG.
With a few exceptions, the entire Wiring/Arduino language is supported. However, there are some subtle differences, most of which are improvements:
Can’t find your shield? Check out the Compatible Shields page on our wiki.
|Ethernet shield||Yes!||Tested; no library yet|
|WiFi Shield||Yes!||Tested; preliminary library support|
|MIDI shield||Yes!||Tested; no library yet|
|Bluetooth shield||Unknown||Some Bluetooth <-> UART boards have been tested and are known to work.|
The state of currently ported Arduino libraries is the Maple Library Reference.
|Wire||Preliminary||In progress; see library reference.|
|LiquidCrystal||Yes||Included since IDE 0.0.7|
|EEPROM||(Unsupported) third-party emulation||The Maple doesn’t have EEPROM; it uses flash instead. There is an EEPROM emulation library by x893, but we haven’t tested it.|
|Servo||Yes||Included since IDE 0.0.9|
In addition to the suggestions in this section, you may find many of the individual language reference pages useful. As appropriate, these have “Arduino Compatibility” sections; one good example is the analogWrite() function.