Вы находитесь на странице: 1из 77

PDF generated using the open source mwlib toolkit. See http://code.pediapress.com/ for more information.

PDF generated at: Wed, 04 Dec 2013 07:33:23 UTC

Arduino 1
Single-board microcontroller 7
Atmel AVR 12
Atmel AVR instruction set 25
Orthogonal instruction set 31
Open-source hardware 33
List of Arduino compatibles 37
Wiring (development platform) 63
Processing (programming language) 65
Article Sources and Contributors 72
Image Sources, Licenses and Contributors 73
Article Licenses
License 75
"Arduino Uno" Revision 3
Type Single-board microcontroller
Arduino is a single-board microcontroller to make using electronics in multidisciplinary projects more accessible.
The hardware consists of an open-source hardware board designed around an 8-bit Atmel AVR microcontroller, or a
32-bit Atmel ARM. The software consists of a standard programming language compiler and a boot loader that
executes on the microcontroller.
Arduino boards can be purchased pre-assembled or as do-it-yourself kits. Hardware design information is available
for those who would like to assemble an Arduino by hand. It was estimated in mid-2011 that over 300,000 official
Arduinos had been commercially produced.
Arduino started in 2005 as a project for students at the Interaction Design Institute Ivrea in Ivrea, Italy. At that time
program students used a "BASIC Stamp" at a cost of $100, considered expensive for students. Massimo Banzi, one
of the founders, taught at Ivrea.
A hardware thesis was contributed for a wiring design by Colombian student Hernando Barragan. After the wiring
platform was complete, researchers worked to make it lighter, less expensive, and available to the open source
community. The school eventually closed down, so these researchers, one of them David Cuartielles, promoted the
The current prices run around $30 and related "clones" as low as $9.
An official Arduino Uno with descriptions of the
I/O locations
A 3rd-party Arduino board with a RS-232 serial
interface (upper left) and an Atmel ATmega8
microcontroller chip (black, lower right); the 14
digital I/O pins are located at the top and the six
analog input pins at the lower right.
An Arduino board consists of an Atmel 8-bit AVR microcontroller
with complementary components to facilitate programming and
incorporation into other circuits. An important aspect of the Arduino is
the standard way that connectors are exposed, allowing the CPU board
to be connected to a variety of interchangeable add-on modules known
as shields. Some shields communicate with the Arduino board directly
over various pins, but many shields are individually addressable via an
IC serial bus, allowing many shields to be stacked and used in parallel.
Official Arduinos have used the megaAVR series of chips, specifically
the ATmega8, ATmega168, ATmega328, ATmega1280, and
ATmega2560. A handful of other processors have been used by
Arduino compatibles. Most boards include a 5volt linear regulator and
a 16MHz crystal oscillator (or ceramic resonator in some variants),
although some designs such as the LilyPad run at 8MHz and dispense
with the onboard voltage regulator due to specific form-factor
restrictions. An Arduino's microcontroller is also pre-programmed with
a boot loader that simplifies uploading of programs to the on-chip flash
memory, compared with other devices that typically need an external
At a conceptual level, when using the Arduino software stack, all
boards are programmed over an RS-232 serial connection, but the way
this is implemented varies by hardware version. Serial Arduino boards
contain a level shifter circuit to convert between RS-232-level and
TTL-level signals. Current Arduino boards are programmed via USB,
implemented using USB-to-serial adapter chips such as the FTDI FT232. Some variants, such as the Arduino Mini
and the unofficial Boarduino, use a detachable USB-to-serial adapter board or cable, Bluetooth or other methods.
(When used with traditional microcontroller tools instead of the Arduino IDE, standard AVR ISP programming is
The Arduino board exposes most of the microcontroller's I/O pins for use by other circuits. The Diecimila,
Duemilanove, and current Uno provide 14 digital I/O pins, six of which can produce pulse-width modulated signals,
and six analog inputs. These pins are on the top of the board, via female 0.10-inch (2.5mm) headers. Several plug-in
application shields are also commercially available.
The Arduino Nano, and Arduino-compatible Bare Bones Board and Boarduino boards may provide male header pins
on the underside of the board to be plugged into solderless breadboards.
There are many Arduino-compatible and Arduino-derived boards. Some are functionally equivalent to an Arduino
and may be used interchangeably. Many are the basic Arduino with the addition of commonplace output drivers,
often for use in school-level education to simplify the construction of buggies and small robots. Others are
electrically equivalent but change the form factor, sometimes permitting the continued use of Shields, sometimes
not. Some variants use completely different processors, with varying levels of compatibility.
Official boards
The original Arduino hardware is manufactured by the Italian company Smart Projects. Some Arduino-branded
boards have been designed by the American company SparkFun Electronics.
Sixteen versions of the Arduino
hardware have been commercially produced to date.
Example Arduino boards
Arduino Diecimila Arduino Duemilanove (rev
Arduino UNO Arduino Leonardo
Arduino Mega Arduino
Arduino Due
LilyPad Arduino (rev 2007)
Arduino and Arduino-compatible boards make use of shieldsprinted circuit expansion boards that plug into the
normally supplied Arduino pin-headers. Shields can provide motor controls, GPS, ethernet, LCD display, or
breadboarding (prototyping). A number of shields can also be made DIY.
Example Arduino shields
Multiple shields can be
stacked. In this example the
top shield contains a
solderless breadboard
Screw-terminal breakout shield
in a wing-type format
Adafruit Motor Shield with screw
terminals for connection to
Adafruit Datalogging Shield with
a SD slot and Real-Time Clock
Arduino Software IDE
A screenshot of the Arduino IDE showing the "Blink" program, a simple beginner program
Developer(s) Arduino Software
Stable release 1.0.5 / May15,2013
Preview release 1.5.4 Beta / September10,2013
Written in Java, C and C++
Operating system Cross-platform
Type Integrated development environment
License LGPL or GPL license
The Arduino integrated development environment (IDE) is a cross-platform application written in Java, and is
derived from the IDE for the Processing programming language and the Wiring projects. It is designed to introduce
programming to artists and other newcomers unfamiliar with software development. It includes a code editor with
features such as syntax highlighting, brace matching, and automatic indentation, and is also capable of compiling and
uploading programs to the board with a single click. A program or code written for Arduino is called a "sketch".
Arduino programs are written in C or C++. The Arduino IDE comes with a software library called "Wiring" from the
original Wiring project, which makes many common input/output operations much easier. Users only need define
two functions to make a runnable cyclic executive program:
setup(): a function run once at the start of a program that can initialize settings
loop(): a function called repeatedly until the board powers off
A typical first program for a microcontroller simply blinks an LED on and off. In the Arduino environment, the user
might write a program like this:
The integrated pin 13 LED
#define LED_PIN 13
void setup () {
pinMode (LED_PIN, OUTPUT); // Enable pin 13 for digital output
void loop () {
digitalWrite (LED_PIN, HIGH); // Turn on the LED
delay (1000); // Wait one second (1000 milliseconds)
digitalWrite (LED_PIN, LOW); // Turn off the LED
delay (1000); // Wait one second
It is a feature of most Arduino boards that they have an LED and load resistor connected between pin 13 and ground;
a convenient feature for many simple tests. The previous code would not be seen by a standard C++ compiler as a
valid program, so when the user clicks the "Upload to I/O board" button in the IDE, a copy of the code is written to a
temporary file with an extra include header at the top and a very simple main() function at the bottom, to make it a
valid C++ program.
The Arduino IDE uses the GNU toolchain and AVR Libc to compile programs, and uses avrdude to upload programs
to the board.
As the Arduino platform uses Atmel microcontrollers, Atmel's development environment, AVR Studio or the newer
Atmel Studio, may also be used to develop software for the Arduino.
The core Arduino developer team is composed of Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino,
David Mellis and Nicholas Zambetti. Massimo Banzi was interviewed on the March 21st, 2009 episode (Episode 61)
of FLOSS Weekly on the TWiT.tv network, in which he discussed the history and goals of the Arduino project. He
also gave a talk at TEDGlobal 2012 Conference, where he outlined various uses of Arduino boards around the world.
Arduino is open source hardware: the Arduino hardware reference designs are distributed under a Creative
Commons Attribution Share-Alike 2.5 license and are available on the Arduino Web site. Layout and production
files for some versions of the Arduino hardware are also available. The source code for the IDE is available and
released under the GNU General Public License, version 2.
Although the hardware and software designs are freely available under copyleft licenses, the developers have
requested that the name "Arduino" be exclusive to the official product and not be used for derivative works without
permission. The official policy document on the use of the Arduino name emphasizes that the project is open to
incorporating work by others into the official product. Several Arduino-compatible products commercially released
have avoided the "Arduino" name by using "-duino" name variants.
Xoscillo: open-source oscilloscope
Scientific equipment
Arduinome: a MIDI controller device that mimics the Monome
OBDuino: a trip computer that uses the on-board diagnostics interface found in most modern cars
The Humane Reader and Humane PC from Humane Informatics: low-cost electronic devices with TV-out that
can hold a five thousand book library (e.g. offline Wikipedia compilations) on a microSD card
Ardupilot: drone software / hardware
The Arduino project received an honorary mention in the Digital Communities category at the 2006 Prix Ars
[1] http:/ / www. arduino.cc
[2] Schmidt, M. ["Arduino: A Quick Start Guide"], Pragmatic Bookshelf, January 22, 2011, Pg. 201
[3] http:/ / arduino.cc/ en/ Main/ Software
[4] ArduinoPhone (http:/ / www. instructables. com/ id/ ArduinoPhone/ ). Instructables.com (2013-07-17). Retrieved on 2013-08-04.
External links
Official website (http:/ / arduino. cc/ )
Arduino The Documentary (http:/ / www. imdb. com/ title/ tt1869268/ ) at the Internet Movie Database, YouTube
(https:/ / www. youtube. com/ watch?v=8zB2KIm4EEQ), Vimeo (http:/ / vimeo. com/ 18539129)
Simple Arduino setup process. (https:/ / exosite. zendesk. com/ hc/ en-us/ articles/
Documentary about Arduino (http:/ / tv. wired. it/ entertainment/ 2012/ 12/ 06/
arduino-creare-e-un-gioco-da-ragazzi-eng-sub. html), Wired Magazine (in Italian)
How to install additional Arduino libraries? (http:/ / arduino. cc/ en/ Guide/ Libraries)
Arduino Cheat Sheet (http:/ / robodino. org/ resources/ arduino)
Arduino Board Pinout Diagrams: Due (http:/ / arduino. cc/ forum/ index. php?/ topic,132130. 0. html), Esplora
(http:/ / www. flickr. com/ photos/ 28521811@N04/ 8469564216/ sizes/ l/ in/ photostream/ ), Leonardo (http:/ /
www. flickr. com/ photos/ 28521811@N04/ 8466547410/ sizes/ l/ in/ photostream/ ), Mega (http:/ / www. flickr.
com/ photos/ 28521811@N04/ 8451024820/ sizes/ l/ in/ photostream/ ), Micro (http:/ / www. flickr. com/ photos/
28521811@N04/ 8471357492/ sizes/ l/ in/ photostream/ ), Mini (http:/ / www. flickr. com/ photos/
28521811@N04/ 8453583648/ sizes/ l/ in/ photostream/ ), Uno (http:/ / www. flickr. com/ photos/
28521811@N04/ 8449936925/ sizes/ l/ in/ photostream/ )
Evolution tree for Arduino (http:/ / i. imgur. com/ yGRLPvL. jpg)
Single-board microcontroller
Single-board microcontroller
The Make Controller Kit with an Atmel
AT91SAM7X256 (ARM) microcontroller.
A single-board microcontroller is a microcontroller built onto a
single printed circuit board. This board provides all of the circuitry
necessary for a useful control task: microprocessor, I/O circuits, clock
generator, RAM, stored program memory and any support ICs
necessary. The intention is that the board is immediately useful to an
application developer, without needing to spend time and effort in
developing the controller hardware.
As they are usually low-cost hardware, and have an especially low
capital cost for development, single-board microcontrollers have long
been popular in education. They are also a popular means for
developers to gain hands-on experience with a new processor family.
Single-board microcontrollers appeared in the late 1970s when the first generations of microprocessors, such as the
6502 and the Z80, made it practical to build an entire controller on a single board, and affordable to dedicate a
computer to a relatively minor task.
In March 1976, Intel announced a single-board computer product that integrated all the support components required
for their 8080 microprocessor, along with 1 kbyte of RAM, 4 kbytes of user-programmable ROM, and 48 lines of
parallel digital I/O with line drivers. The board also offered expansion through a bus connector, but it could be used
without an expansion card cage where applications didn't require additional hardware. Software development for this
system was hosted on Intel's Intellec MDS microcomputer development system; this provided assembler and PL/M
support, and permitted in-circuit emulation for debugging.
Processors of this era required a number of support chips in addition. RAM and EPROM were separate, often
requiring memory management or refresh circuitry for dynamic memory as well. I/O processing might be carried out
by a single chip such as the 8255, but frequently required several more chips.
A single-board microcontroller differs from a single-board computer in that it lacks the general purpose user
interface and mass storage interfaces that a more general-purpose computer would have. Compared to a
microprocessor development board, a microcontroller board would emphasize digital and analog control
interconnections to some controlled system, where a development board might by comparison have only a few or no
discrete or analog input/output devices. The development board exists to showcase or to train on some particular
processor family and this internal implementation is more important than the external function.
Internal bus
The bus of the early single-board devices, such as the Z80 and 6502, was universally a Von Neumann architecture.
Program and data memory were accessed by the same shared bus, even though they were stored in fundamentally
different types of memory: ROM for programs and RAM for data. This bus architecture was needed to economise on
the number of pins needed from the limited 40 available for the processor's ubiquitous dual-in-line IC package.
It was common to offer the internal bus through an expansion connector, or at least the space for such a connector to
be soldered on. This was a low-cost option and offered the potential for expansion, even if it was rarely made use of.
Typical expansions would be I/O devices, or memory expansion. It was unusual to add peripheral devices such as
tape or disk storage, or even a CRT display
Single-board microcontroller
When single-chip microcontrollers, such as the 8048, became available later on, the bus no longer needed to be
exposed outside the package as all the necessary memory could be provided within the chip package. This generation
of processors used a Harvard architecture of separate program and data buses, both internal to the chip. Many of
these processors used a modified Harvard architecture, where some write access was possible to the program data
space, thus permitting in-circuit programming. None of these processors required, or supported, a Harvard bus across
a single-board microcontroller. Where they supported a bus for expansion of peripherals, this used a dedicated I/O
bus, such as I
C, One-wire or various serial buses.
External bus expansion
Some microcontroller boards using a general-purpose microprocessor can bring the address and data bus of the
processor to an expansion connector, allowing additional memory or peripherals to be added. This would provide
resources not already present on the single board system. Since not all systems require expansion, the connector may
be an option, with a mounting position provided for the connector for installation by the user if desired.
Input and output
Arduino Diecimila with Atmel ATMEGA168
Microcontroller systems provide multiple forms of input and output
signals to allow application software to control an external
"real-world" system. Discrete digital I/O provides a single bit of data
(on, or off). Analog signals, representing a continuously variable range
such as temperature or pressure, can also be inputs and outputs for
Discrete digital inputs and outputs might only be buffered from the
microprocessor data bus by an addressable latch, or might be operated
by a specialized input/output integrated circuit such as an Intel 8255 or
Motorola 6821 parallel input/output adapter. Later single-chip
micrcontrollers have input and output pins available. The input/output circuits usually do not provide enough current
to directly operate such devices as lamps or motors, so solid-state relays are operated by the microcontroller digital
outputs, and inputs are isolated by signal conditioning level-shifting and protection circuits.
One or more analog inputs, with an analog multiplexer and common analog to digital converter, are found on some
microcontroller boards. Analog outputs may use a digital-to-analog converter, or on some microcontrollers may be
controlled by pulse-width modulation. As for discrete inputs, external circuits may be required to scale inputs, or to
provide such functions as bridge excitation or cold junction compensation.
To control component costs, many boards were designed with extra hardware interface circuits but the components
for these circuits weren't installed and the board was left bare. The circuit was only added as an option on delivery,
or could be populated later.
It is common practice for boards to include "prototyping areas", areas of the board already laid out as a solderable
breadboard area with the bus and power rails available, but without a defined circuit. Several controllers, particularly
those intended for training, also included a pluggable re-usable breadboard for easy prototyping of extra I/O circuits
that could be changed or removed for later projects.
Single-board microcontroller
Communications and user interfaces
Communications interfaces vary depending on the age of the microcontroller system. Early systems might
implement a serial port to provide RS-232 or current loop. The serial port could be used by the application program,
or could be used, in conjunction with a monitor ROM, to transfer programs into the microcontroller memory.
Current microcontrollers may support USB, wireless network (Wi-Fi, ZigBee, or others) ports, or provide an
Ethernet connection, and may support a TCP/IP protocol stack. Some devices have firmware available to implement
a Web server, allowing an application developer to rapidly build a Web-enabled instrument or system.
Many of the earliest systems had no internal facility for programming at all, and relied on a separate "host" system.
This programming was typically in assembly language, sometimes C or even PL/M, and then cross-assembled or
cross-compiled on the host. Some single-board microcontrollers support a BASIC language system, allowing
programs to be developed on the target hardware. Hosted development allows all the storage and peripherals of a
desktop computer to be used, providing a more powerful development environment.
EPROM burning
Early microcontrollers relied on erasable programmable read-only memory (EPROM) devices to hold the application
program. The completed object code from a host system would be "burned" onto an EPROM with an EPROM
programmer, this EPROM was then physically plugged into the board. As the EPROM would be removed and
replaced many times during program development, it was usual to provide a ZIF socket to avoid wear or damage.
Erasing an EPROM with a UV eraser takes a considerable time, and so it was also usual for a developer to have
several EPROMs in circulation at any one time.
Some microcontroller devices were available with on-board EPROM; these, too, would be programmed in a separate
burner, then put into a socket on the target system.
The use of EPROM sockets allowed field update of the application program, either to fix errors or to provide
updated features.
Keypad monitors
A single-board computer with a hex keypad and
7-segment display
Where the single-board controller formed the entire development
environment (typically in education) the board might also be provided
with a simple hexadecimal keypad, calculator-style LED display and a
"monitor" program set permanently in ROM. This monitor allowed
machine code programs to be entered directly through the keyboard
and held in RAM. These programs were in machine code, not even in
assembly language, and were assembled by hand on paper first. It's
arguable as to which process was more time-consuming and error
prone: assembling by hand, or keying byte-by-byte.
Single-board "keypad and calculator display" microcontrollers of this
type were very similar to some low-end microcomputers of the time,
such as the KIM-1 or the Microprofessor I. Some of these
microprocessor "trainer" systems are still in production today, as a very
low-cost introduction to microprocessors at the hardware programming
Single-board microcontroller
Hosted development
When desktop personal computers appeared, initially CP/M or Apple II, then later the IBM PC and compatibles,
there was a shift to hosted development. Hardware was now cheaper and RAM capacity had expanded such that it
was possible to download the program through the serial port and hold it in RAM. This massive reduction in the
cycle time to test a new version of a program gave an equally large boost in development speed.
This program memory was still volatile and would be lost if power was turned off. Flash memory was not yet
available at a viable price. As a completed controller project usually required to be non-volatile, the final step in a
project was often to burn an EPROM again.
Single-chip microcontrollers
A 8048-family microcontroller with on-board UV
EPROM, the 8749
A development board for a PIC family device
Single-chip microcontrollers such as the 8748 combined many of the
features of the previous boards into a single IC package. Single-chip
microcontrollers integrate memory (both RAM and ROM) on-package
and so do not need to expose the data and address bus through the IC
package's pins. These pins are then available for I/O lines. These
changes reduce the area required on a printed circuit board and
simplify the design of a single-board microcontroller. Examples of
single-chip microcontrollers include:
Atmel AVR
Program memory
For production use as embedded systems, the on-board ROM would be
either mask programmed at the chip factory or one-time programmed
(OTP) by the developer as a PROM. PROMs often used the same UV
EPROM technology for the chip, but in a cheaper package without the
transparent erasure window. During program development it was still
necessary to burn EPROMs, this time the entire controller IC, and so ZIF sockets would be provided.
With the development of affordable EEPROM, EAROM and eventually flash memory, it became practical to attach
the controller permanently to the board and to download program code to it through a serial connection to a host
computer. This was termed "in-circuit programming". Erasure of old programs was carried out by either over-writing
them with a new download, or bulk erasing them electrically (for EEPROM) which was slower, but could be carried
out in-situ.
The main function of the controller board was now to carry the support circuits for this serial interface, or USB on
later boards. As a further convenience feature during development, many boards also carried low-cost features like
LED monitors of the I/O lines or reset switches mounted on board.
Single-board microcontroller
Single-board microcontrollers today
Dwengo board
Microcontrollers are now cheap and simple to design circuit boards for.
Development host systems are also cheap, especially when using open
source software. Higher level programming languages abstract details
of the hardware, making differences between specific processors less
obvious to the application programmer. Rewritable flash memory has
replaced slow programming cycles, at least during program
development. Accordingly almost all development now is based on
cross-compilation from personal computers and download to the
controller board through a serial-like interface, usually appearing to the
host as a USB device.
The original market demand of a simplified board implementation is
no longer so relevant to microcontrollers. Single-board
microcontrollers are still important, but have shifted their focus to:
Easily accessible platforms aimed at traditionally "non-programmer" groups, such as artists, designers, hobbyists,
and others interested in creating interactive objects or environments.
Some typical projects in 2011 included;
the backup control of DMX stage lights and special effects, multi-camera control, autonomous fighting robots,
controlling bluetooth projects from a computer or smart phone, LEDs and multiplexing, displays, audio, motors,
mechanics, and power control.
These controllers may be embedded to form part of a physical computing
project. Popular choices for this work are the Arduino, Dwengo or the Wiring (development platform).
Technology demonstrator boards for innovative processors or peripheral features:
AVR Butterfly
Parallax Propeller
[1] http:/ / www. dvq. com/ docs/ intel_sbc_80_10.pdf Intel Single Board Computer datasheet, 1975
[2] Arduino's home page (http:/ / www.arduino. cc/ )
[3] Arduino User's forum (http:/ / arduino. cc/ forum/ )
[4] Wiring.org's Wiring development platform home page (http:/ / wiring. org. co/ )
External links
Atmega8 Development board (http:/ / www. robotplatform. com/ howto/ dev_board/ atmega8_dev_board_1.
html) - DIY AVR development board based on Atmel's AVR microcontroller
Atmel AVR
Atmel AVR
Atmel ATmega8 in 28-pin narrow DIP
The AVR is a modified Harvard architecture 8-bit RISC single chip
microcontroller which was developed by Atmel in 1996. The AVR was
one of the first microcontroller families to use on-chip flash memory
for program storage, as opposed to one-time programmable ROM,
EPROM, or EEPROM used by other microcontrollers at the time.
Brief history
The AVR architecture was conceived by two students at the
Norwegian Institute of Technology (NTH) Alf-Egil Bogen Blog
(www.alfbogen.com) and Vegard Wollan.
The original AVR MCU was developed at a local ASIC house in Trondheim, Norway called Nordic VLSI at the
time, now Nordic Semiconductor, where Bogen and Wollan were working as students.
[citation needed]
It was known as
a RISC (Micro RISC)
[citation needed]
and was available as silicon IP/building block from Nordic VLSI.
[citation needed]
When the technology was sold to Atmel from Nordic VLSI,
[citation needed]
the internal architecture was further
developed by Bogen and Wollan at Atmel Norway, a subsidiary of Atmel. The designers worked closely with
compiler writers at IAR Systems to ensure that the instruction set provided for more efficient compilation of
high-level languages. Atmel says that the name AVR is not an acronym and does not stand for anything in particular.
The creators of the AVR give no definitive answer as to what the term "AVR" stands for. However, it is commonly
accepted that AVR stands for Alf (Egil Bogen) and Vegard (Wollan)'s RISC processor.
Note that the use of "AVR" in this article generally refers to the 8-bit RISC line of Atmel AVR Microcontrollers.
Among the first of the AVR line was the AT90S8515, which in a 40-pin DIP package has the same pinout as an
8051 microcontroller, including the external multiplexed address and data bus. The polarity of the RESET line was
opposite (8051's having an active-high RESET, while the AVR has an active-low RESET), but other than that, the
pinout was identical.
Device overview
The AVR is a modified Harvard architecture machine where program and data are stored in separate physical
memory systems that appear in different address spaces, but having the ability to read data items from program
memory using special instructions.
Basic families
AVRs are generally classified into six broad groups:
tinyAVR the ATtiny series
0.516kB program memory
632-pin package
Limited peripheral set
megaAVR the ATmega series
4512kB program memory
28100-pin package
Extended instruction set (multiply instructions and instructions for handling larger program memories)
Extensive peripheral set
Atmel AVR
XMEGA the ATxmega series
16384kB program memory
4464100-pin package (A4, A3, A1)
Extended performance features, such as DMA, "Event System", and cryptography support.
Extensive peripheral set with ADCs
Application-specific AVR
megaAVRs with special features not found on the other members of the AVR family, such as LCD controller,
USB controller, advanced PWM, CAN, etc.
FPGA 5K to 40K gates
SRAM for the AVR program code, unlike all other AVRs
AVR core can run at up to 50MHz
32-bit AVRs
In 2006 Atmel released microcontrollers based on the new, 32-bit, AVR32 architecture. They include SIMD
and DSP instructions, along with other audio and video processing features. This 32-bit family of devices is
intended to compete with the ARM based processors. The instruction set is similar to other RISC cores, but it
is not compatible with the original AVR or any of the various ARM cores.
Device architecture
Flash, EEPROM, and SRAM are all integrated onto a single chip, removing the need for external memory in most
applications. Some devices have a parallel external bus option to allow adding additional data memory or
memory-mapped devices. Almost all devices (except the smallest TinyAVR chips) have serial interfaces, which can
be used to connect larger serial EEPROMs or flash chips.
Program memory
Program instructions are stored in non-volatile flash memory. Although the MCUs are 8-bit, each instruction takes
one or two 16-bit words.
The size of the program memory is usually indicated in the naming of the device itself (e.g., the ATmega64x line has
64kB of flash while the ATmega32x line has 32kB).
There is no provision for off-chip program memory; all code executed by the AVR core must reside in the on-chip
flash. However, this limitation does not apply to the AT94 FPSLIC AVR/FPGA chips.
Atmel AVR
Internal data memory
The data address space consists of the register file, I/O registers, and SRAM.
Internal registers
Atmel ATxmega128A1 in 100-pin TQFP
The AVRs have 32 single-byte registers and are classified as 8-bit
RISC devices.
In most variants of the AVR architecture, the working registers are
mapped in as the first 32 memory addresses (0000
) followed
by the 64 I/O registers (0020
Actual SRAM starts after these register sections (address 0060
(Note that the I/O register space may be larger on some more extensive
devices, in which case the memory mapped I/O registers will occupy a
portion of the SRAM address space.)
Even though there are separate addressing schemes and optimized
opcodes for register file and I/O register access, all can still be
addressed and manipulated as if they were in SRAM.
In the XMEGA variant, the working register file is not mapped into the data address space; as such, it is not possible
to treat any of the XMEGA's working registers as though they were SRAM. Instead, the I/O registers are mapped
into the data address space starting at the very beginning of the address space. Additionally, the amount of data
address space dedicated to I/O registers has grown substantially to 4096 bytes (0000
). As with previous
generations, however, the fast I/O manipulation instructions can only reach the first 64 I/O register locations (the
first 32 locations for bitwise instructions). Following the I/O registers, the XMEGA series sets aside a 4096 byte
range of the data address space which can be used optionally for mapping the internal EEPROM to the data address
space (1000
). The actual SRAM is located after these ranges, starting at 2000
Almost all AVR microcontrollers have internal EEPROM for semi-permanent data storage. Like flash memory,
EEPROM can maintain its contents when electrical power is removed.
In most variants of the AVR architecture, this internal EEPROM memory is not mapped into the MCU's addressable
memory space. It can only be accessed the same way an external peripheral device is, using special pointer registers
and read/write instructions which makes EEPROM access much slower than other internal RAM.
However, some devices in the SecureAVR (AT90SC) family
use a special EEPROM mapping to the data or
program memory depending on the configuration. The XMEGA family also allows the EEPROM to be mapped into
the data address space.
Since the number of writes to EEPROM is not unlimited Atmel specifies 100,000 write cycles in their datasheets
a well designed EEPROM write routine should compare the contents of an EEPROM address with desired
contents and only perform an actual write if the contents need to be changed.
Note that erase and write can be performed separately in many cases, byte-by-byte, which may also help prolong life
when bits only need to be set to all 1s (erase) or selectively cleared to 0s (write).
Atmel AVR
Program execution
Atmel's AVRs have a two stage, single level pipeline design. This means the next machine instruction is fetched as
the current one is executing. Most instructions take just one or two clock cycles, making AVRs relatively fast among
eight-bit microcontrollers.
The AVR processors were designed with the efficient execution of compiled C code in mind and have several
built-in pointers for the task.
Instruction set
The AVR instruction set is more orthogonal than those of most eight-bit microcontrollers, in particular the 8051
clones and PIC microcontrollers with which AVR competes today. However, it is not completely regular:
Pointer registers X, Y, and Z have addressing capabilities that are different from each other.
Register locations R0 to R15 have different addressing capabilities than register locations R16 to R31.
I/O ports 0 to 31 have different addressing capabilities than I/O ports 32 to 63.
CLR affects flags, while SER does not, even though they are complementary instructions. CLR set all bits to zero
and SER sets them to one. (Note that CLR is pseudo-op for EOR R, R; and SER is short for LDI R,$FF. Math
operations such as EOR modify flags while moves/loads/stores/branches such as LDI do not.)
Accessing read-only data stored in the program memory (flash) requires special LPM instructions; the flash bus is
otherwise reserved for instruction memory.
Additionally, some chip-specific differences affect code generation. Code pointers (including return addresses on the
stack) are two bytes long on chips with up to 128 kBytes of flash memory, but three bytes long on larger chips; not
all chips have hardware multipliers; chips with over 8 kBytes of flash have branch and call instructions with longer
ranges; and so forth.
The mostly regular instruction set makes programming it using C (or even Ada) compilers fairly straightforward.
GCC has included AVR support for quite some time, and that support is widely used. In fact, Atmel solicited input
from major developers of compilers for small microcontrollers, to determine the instruction set features that were
most useful in a compiler for high-level languages.
MCU speed
The AVR line can normally support clock speeds from 0 to 20MHz, with some devices reaching 32MHz. Lower
powered operation usually requires a reduced clock speed. All recent (Tiny, Mega, and Xmega, but not 90S) AVRs
feature an on-chip oscillator, removing the need for external clocks or resonator circuitry. Some AVRs also have a
system clock prescaler that can divide down the system clock by up to 1024. This prescaler can be reconfigured by
software during run-time, allowing the clock speed to be optimized.
Since all operations (excluding literals) on registers R0 - R31 are single cycle, the AVR can achieve up to 1 MIPS
per MHz, i.e. an 8MHz processor can achieve up to 8 MIPS. Loads and stores to/from memory take two cycles,
branching takes two cycles. Branches in the latest "3-byte PC" parts such as ATmega2560 are one cycle slower than
on previous devices.
Atmel AVR
Atmel STK500 development board
AVRs have a large following due to the free and inexpensive
development tools available, including reasonably priced development
boards and free development software. The AVRs are sold under
various names that share the same basic core, but with different
peripheral and memory combinations. Compatibility between chips in
each family is fairly good, although I/O controller features may vary.
See external links for sites relating to AVR development.
CurrentWikipedia:Manual of Style/Dates and numbers#Chronological items AVRs offer a wide range of features:
Multifunction, bi-directional general-purpose I/O ports with configurable, built-in pull-up resistors
Multiple internal oscillators, including RC oscillator without external parts
Internal, self-programmable instruction flash memory up to 256kB (384kB on XMega)
In-system programmable using serial/parallel low-voltage proprietary interfaces or JTAG
Optional boot code section with independent lock bits for protection
On-chip debugging (OCD) support through JTAG or debugWIRE on most devices
The JTAG signals (TMS, TDI, TDO, and TCK) are multiplexed on GPIOs. These pins can be configured to
function as JTAG or GPIO depending on the setting of a fuse bit, which can be programmed via ISP or HVSP.
By default, AVRs with JTAG come with the JTAG interface enabled.
debugWIRE uses the /RESET pin as a bi-directional communication channel to access on-chip debug circuitry.
It is present on devices with lower pin counts, as it only requires one pin.
Internal data EEPROM up to 4kB
Internal SRAM up to 16kB (32kB on XMega)
External 64kB little endian data space on certain models, including the Mega8515 and Mega162.
The external data space is overlaid with the internal data space, such that the full 64kB address space does not
appear on the external bus and accesses to e.g. address 0100
will access internal RAM, not the external bus.
In certain members of the XMega series, the external data space has been enhanced to support both SRAM and
SDRAM. As well, the data addressing modes have been expanded to allow up to 16MB of data memory to be
directly addressed.
AVRs generally do not support executing code from external memory. Some ASSPs using the AVR core do
support external program memory.
8-bit and 16-bit timers
PWM output (some devices have an enhanced PWM peripheral which includes a dead-time generator)
Input capture that record a time stamp triggered by a signal edge
Analog comparator
10 or 12-bit A/D converters, with multiplex of up to 16 channels
12-bit D/A converters
A variety of serial interfaces, including
IC compatible Two-Wire Interface (TWI)
Synchronous/asynchronous serial peripherals (UART/USART) (used with RS-232, RS-485, and more)
Serial Peripheral Interface Bus (SPI)
Universal Serial Interface (USI) for two or three-wire synchronous data transfer
Atmel AVR
Brownout detection
Watchdog timer (WDT)
Multiple power-saving sleep modes
Lighting and motor control (PWM-specific) controller models
CAN controller support
USB controller support
Proper full-speed (12 Mbit/s) hardware & Hub controller with embedded AVR.
Also freely available low-speed (1.5 Mbit/s) (HID) bitbanging software emulations
Ethernet controller support
LCD controller support
Low-voltage devices operating down to 1.8V (to 0.7V for parts with built-in DCDC upconverter)
picoPower devices
DMA controllers and "event system" peripheral communication.
Fast cryptography support for AES and DES
Programming interfaces
There are many means to load program code into an AVR chip. The methods to program AVR chips varies from
AVR family to family.
6- and 10-pin ISP header diagrams
The in-system programming (ISP) programming method is
functionally performed through SPI, plus some twiddling of the Reset
line. As long as the SPI pins of the AVR are not connected to anything
disruptive, the AVR chip can stay soldered on a PCB while
reprogramming. All that is needed is a 6-pin connector and
programming adapter. This is the most common way to develop with
an AVR.
The Atmel AVR ISP mkII device connects to a computer's USB port
and performs in-system programming using Atmel's software.
AVRDUDE (AVR Downloader/UploaDEr) runs on Linux, FreeBSD, Windows, and Mac OS X, and supports a
variety of in-system programming hardware, including Atmel AVR ISP mkII, Atmel JTAG ICE, older Atmel
serial-port based programmers, and various third-party and "do-it-yourself" programmers.
The Program and Debug Interface (PDI) is an Atmel proprietary interface for external programming and on-chip
debugging of XMEGA devices. The PDI supports high-speed programming of all non-volatile memory (NVM)
spaces; flash, EEPROM, fuses, lock-bits and the User Signature Row. This is done by accessing the XMEGA NVM
controller through the PDI interface, and executing NVM controller commands. The PDI is a 2-pin interface using
the Reset pin for clock input (PDI_CLK) and a dedicated data pin (PDI_DATA) for input and output.
Atmel AVR
High voltage serial
High-voltage serial programming (HVSP) is mostly the backup mode on smaller AVRs. An 8-pin AVR package
does not leave many unique signal combinations to place the AVR into a programming mode. A 12 volt signal,
however, is something the AVR should only see during programming and never during normal operation.
High voltage parallel
High voltage parallel programming (HVPP) is considered the "final resort" and may be the only way to fix AVR
chips with bad fuse settings.
Most AVR models can reserve a bootloader region, 256B to 4KB, where re-programming code can reside. At reset,
the bootloader runs first, and does some user-programmed determination whether to re-program, or jump to the main
application. The code can re-program through any interface available, it could read an encrypted binary through an
Ethernet adapter like PXE. Atmel has application notes and code pertaining to many bus interfaces.
The AT90SC series of AVRs are available with a factory mask-ROM rather than flash for program memory.
Because of the large up-front cost and minimum order quantity, a mask-ROM is only cost-effective for high
production runs.
aWire is a new one-wire debug interface available on the new UC3L AVR32 devices.
Debugging interfaces
The AVR offers several options for debugging, mostly involving on-chip debugging while the chip is in the target
is Atmel's solution for providing on-chip debug capabilities via a single microcontroller pin. It is
particularly useful for lower pin count parts which cannot provide the four "spare" pins needed for JTAG. The
JTAGICE mkII, mkIII and the AVR Dragon support debugWIRE. debugWIRE was developed after the original
JTAGICE release, and now clones support it.
The Joint Test Action Group (JTAG) feature provides access to on-chip debugging functionality while the chip is
running in the target system. JTAG allows accessing internal memory and registers, setting breakpoints on code, and
single-stepping execution to observe system behaviour.
Atmel provides a series of JTAG adapters for the AVR:
1. 1. The JTAGICE 3 is the latest member of the JTAGICE family (JTAGICE mkIII). It supports JTAG, aWire, SPI,
and PDI interfaces.
2. 2. The JTAGICE mkII replaces the JTAGICE and is similarly priced. The JTAGICE mkII interfaces to the PC via
USB, and supports both JTAG and the newer debugWIRE interface. Numerous third-party clones of the Atmel
JTAGICE mkII device started shipping after Atmel released the communication protocol.
Atmel AVR
3. 3. The AVR Dragon is a low-cost (approximately $50) substitute for the JTAGICE mkII for certain target parts. The
AVR Dragon provides in-system serial programming, high-voltage serial programming and parallel
programming, as well as JTAG or debugWIRE emulation for parts with 32KB of program memory or less.
ATMEL changed the debugging feature of AVR Dragon with the latest firmware of AVR Studio 4 - AVR Studio
5 and now it supports devices over 32KB of program memory.
4. The JTAGICE adapter interfaces to the PC via a standard serial port.
[citation needed]
Although the JTAGICE
adapter has been declared "end-of-life" by Atmel, it is still supported in AVR Studio and other tools.
JTAG can also be used to perform a boundary scan test,
which tests the electrical connections between AVRs and
other boundary scan capable chips in a system. Boundary scan is well-suited for a production line, while the hobbyist
is probably better off testing with a multimeter or oscilloscope.
Development tools and evaluation kits
Official Atmel AVR development tools and evaluation kits contain a number of starter kits and debugging tools with
support for most AVR devices:
STK600 starter kit
The STK600 starter kit and development system is an update to the STK500. The STK600 uses a base board, a
signal routing board, and a target board.
The base board is similar to the STK500, in that it provides a power supply, clock, in-system programming, an
RS-232 port and a CAN (Controller Area Network, an automotive standard) port via DE9 connectors, and stake pins
for all of the GPIO signals from the target device.
The target boards have ZIF sockets for DIP, SOIC, QFN, or QFP packages, depending on the board.
The signal routing board sits between the base board and the target board, and routes the signals to the proper pin on
the device board. There are many different signal routing boards that could be used with a single target board,
depending on what device is in the ZIF socket.
The STK600 allows in-system programming from the PC via USB, leaving the RS-232 port available for the target
microcontroller. A 4 pin header on the STK600 labeled 'RS-232 spare' can connect any TTL level USART port on
the chip to an onboard MAX232 chip to translate the signals to RS-232 levels. The RS-232 signals are connected to
the RX, TX, CTS, and RTS pins on the DB-9 connector.
STK500 starter kit
The STK500 starter kit and development system features ISP and high voltage programming (HVP) for all AVR
devices, either directly or through extension boards. The board is fitted with DIP sockets for all AVRs available in
DIP packages.
STK500 Expansion Modules: Several expansion modules are available for the STK500 board:
STK501 - Adds support for microcontrollers in 64-pin TQFP packages.
STK502 - Adds support for LCD AVRs in 64-pin TQFP packages.
STK503 - Adds support for microcontrollers in 100-pin TQFP packages.
STK504 - Adds support for LCD AVRs in 100-pin TQFP packages.
STK505 - Adds support for 14 and 20-pin AVRs.
STK520 - Adds support for 14 and 20, and 32-pin microcontrollers from the AT90PWM and ATmega family.
STK524 - Adds support for the ATmega32M1/C1 32-pin CAN/LIN/Motor Control family.
STK525 - Adds support for the AT90USB microcontrollers in 64-pin TQFP packages.
STK526 - Adds support for the AT90USB microcontrollers in 32-pin TQFP packages
Atmel AVR
STK200 starter kit
The STK200 starter kit and development system has a DIP socket that can host an AVR chip in a 40, 20, or 8-pin
package. The board has a 4 MHz clock source, 8 light-emitting diodes, 8 input buttons, an RS-232 port, a socket for
a 32k SRAM and numerous general I/O. The chip can be programmed with a dongle connected to the parallel-port.
Supported microcontrollers (according to the manual)
Chip Flash size EEPROM SRAM Frequency
AT90S1200 1k 64 0 12 PDIP-20
AT90S2313 2k 128 128 10 PDIP-20
AT90S/LS2323 2k 128 128 10 PDIP-8
AT90S/LS2343 2k 128 128 10 PDIP-8
AT90S4414 4k 256 256 8 PDIP-40
AT90S/LS4434 4k 256 256 8 PDIP-40
AT90S8515 8k 512 512 8 PDIP-40
AT90S/LS8535 8k 512 512 8 PDIP-40
The AVR ISP and AVR ISP mkII are inexpensive tools allowing all AVRs to be programmed via ICSP.
The AVR ISP connects to a PC via a serial port and draws power from the target system. The AVR ISP allows using
either of the "standard" ICSP pinouts, either the 10-pin or 6-pin connector. The AVR ISP has been discontinued,
replaced by the AVR ISP mkII.
The AVR ISP mkII connects to a PC via USB and draws power from USB. LEDs visible through the translucent
case indicate the state of target power.
AVR Dragon
AVR Dragon with ISP programming cable and
attached, blue ZIF Socket.
The Atmel Dragon is an inexpensive tool which connects to a PC via
USB. The Dragon can program all AVRs via JTAG, HVP, PDI, or
ICSP. The Dragon also allows debugging of all AVRs via JTAG, PDI,
or debugWire; a previous limitation to devices with 32kB or less
program memory has been removed in AVR Studio 4.18. The Dragon
has a small prototype area which can accommodate an 8, 28, or 40-pin
AVR, including connections to power and programming pins. There is
no area for any additional circuitry, although this can be provided by a
third-party product called the "Dragon Rider".
The JTAG In Circuit Emulator (JTAGICE) debugging tool supports on-chip debugging (OCD) of AVRs with a
JTAG interface. The original JTAGICE mkI uses an RS-232 interface to a PC and can only program AVR's with a
JTAG interface. The JTAGICE mkI is no longer in production, however it has been replaced by the JTAGICE mkII.
Atmel AVR
The JTAGICE mkII debugging tool supports on-chip debugging (OCD) of AVRs with SPI, JTAG, PDI, and
debugWIRE interfaces. The debugWire interface enables debugging using only one pin (the Reset pin), allowing
debugging of applications running on low pin-count microcontrollers.
The JTAGICE mkII connects using USB, but there is an alternate connection via a serial port, which requires using a
separate power supply. In addition to JTAG, the mkII supports ISP programming (using 6-pin or 10-pin adapters).
Both the USB and serial links use a variant of the STK500 protocol.
The JTAGICE3 updates the mkII with more advanced debugging capabilities and faster programming. It connects
via USB and supports the JTAG, aWire, SPI, and PDI interfaces.
The kit includes several adapters for use with
most interface pinouts.
The AVR ONE! is a professional development tool for all Atmel 8-bit and 32-bit AVR devices with On-Chip Debug
capability. It supports SPI, JTAG, PDI, and aWire programming modes and debugging using debugWIRE, JTAG,
PDI, and aWire interfaces.
Butterfly demonstration board
Atmel ATmega169 in 64-pad MLF package on
the back of an Atmel AVR Butterfly board
The very popular AVR Butterfly demonstration board is a
self-contained, battery-powered computer running the Atmel AVR
ATmega169V microcontroller. It was built to show-off the AVR
family, especially a new built-in LCD interface. The board includes the
LCD screen, joystick, speaker, serial port, real time clock (RTC), flash
memory chip, and both temperature and voltage sensors. Earlier
versions of the AVR Butterfly also contained a CdS photoresistor; it is
not present on Butterfly boards produced after June 2006 to allow
RoHS compliance.
The small board has a shirt pin on its back so it
can be worn as a name badge.
The AVR Butterfly comes preloaded with software to demonstrate the
capabilities of the microcontroller. Factory firmware can scroll your name, display the sensor readings, and show the
time. The AVR Butterfly also has a piezoelectric transducer that can be used to reproduce sounds and music.
The AVR Butterfly demonstrates LCD driving by running a 14-segment, six alpha-numeric character display.
However, the LCD interface consumes many of the I/O pins.
The Butterfly's ATmega169 CPU is capable of speeds up to 8MHz, but it is factory set by software to 2MHz to
preserve the button battery life. A pre-installed bootloader program allows the board to be re-programmed via a
standard RS-232 serial plug with new programs that users can write with the free Atmel IDE tools.
This small board, about half the size of a business card, is priced at slightly more than an AVR Butterfly. It includes
an AT90USB1287 with USB On-The-Go (OTG) support, 16MB of DataFlash, LEDs, a small joystick, and a
temperature sensor. The board includes software which lets it act as a USB mass storage device (its documentation is
shipped on the DataFlash), a USB joystick, and more. To support the USB host capability, it must be operated from a
battery, but when running as a USB peripheral, it only needs the power provided over USB.
Atmel AVR
Only the JTAG port uses conventional 2.54mm pinout. All the other AVR I/O ports require more compact 1.27mm
The AVR Dragon can both program and debug since the 32KB limitation was removed in AVR Studio 4.18, and the
JTAGICE mkII is capable of both programming and debugging the processor. The processor can also be
programmed through USB from a Windows or Linux host, using the USB "Device Firmware Update" protocols.
Atmel ships proprietary (source code included but distribution restricted) example programs and a USB protocol
stack with the device.
LUFA is a third-party free software (MIT license) USB protocol stack for the USBKey and other 8-bit USB AVRs.
Raven wireless kit
The RAVEN kit supports wireless development using Atmel's IEEE 802.15.4 chipsets, for ZigBee and other wireless
stacks. It resembles a pair of wireless more-powerful Butterfly cards, plus a wireless USBKey; and costing about that
much (under $US100). All these boards support JTAG-based development.
The kit includes two AVR Raven boards, each with a 2.4GHz transceiver supporting IEEE 802.15.4 (and a freely
licensed ZigBee stack). The radios are driven with ATmega1284p processors, which are supported by a custom
segmented LCD display driven by an ATmega3290p processor. Raven peripherals resemble the Butterfly: piezo
speaker, DataFlash (bigger), external EEPROM, sensors, 32kHz crystal for RTC, and so on. These are intended for
use in developing remote sensor nodes, to control relays, or whatever is needed.
The USB stick uses an AT90USB1287 for connections to a USB host and to the 2.4GHz wireless links. These are
intended to monitor and control the remote nodes, relying on host power rather than local batteries.
Third-party programmers
A wide variety of third-party programming and debugging tools are available for the AVR. These devices use
various interfaces, including RS-232, PC parallel port, and USB. AVR Freaks
has a comprehensive list.
Atmel AVR usage
Atmel AVR Atmega328 28-pin DIP on an
Arduino Duemilanove board
AVRs have been used in various automotive applications such as
security, safety, powertrain and entertainment systems. Atmel has
recently launched a new publication "Atmel Automotive Compilation"
to help developers with automotive applications. Some current usages
are in BMW, Daimler-Chrysler and TRW.
The Arduino physical computing platform is based on an ATmega328
microcontroller (ATmega168 or ATmega8 in board versions older than
the Diecimila). The ATmega1280 and ATmega2560, with more pinout
and memory capabilities, have also been employed to develop the
Arduino Mega platform. Arduino boards can be used with its language
and IDE, or with more conventional programming environments (C,
assembler, etc.) as just standardized and widely available AVR platforms.
USB-based AVRs have been used in the Microsoft Xbox hand controllers. The link between the controllers and
Xbox is USB.
Atmel AVR
Atmel AVR Atmega8 28-pin DIP on a custom
development board
Numerous companies produce AVR-based microcontroller boards
intended for use by hobbyists, robot builders, experimenters and small
system developers including: Cubloc, gnusb, BasicX, Oak Micros, ZX
Microcontrollers, and myAVR. There is also a large community of
Arduino-compatible boards supporting similar users.
Schneider Electric produces the M3000 Motor and Motion Control
Chip, incorporating an Atmel AVR Core and an advanced motion
controller for use in a variety of motion applications.
FPGA clones
With the growing popularity of FPGAs among the open source community, people have started developing open
source processors compatible with the AVR instruction set. The OpenCores website lists the following major AVR
clone projects:
pAVR, written in VHDL, is aimed at creating the fastest and maximally featured AVR processor, by
implementing techniques not found in the original AVR processor such as deeper pipelining.
avr_core, written in VHDL, is a clone aimed at being as close as possible to the ATmega103.
Navr written in Verilog, implements all Classic Core instructions and is aimed at high performance and low
resource usage. It does not support interrupts.
[1] http:/ / www. alfbogen.com
[2] Since 1996, NTH has become part of the Norwegian University of Science and Technology (NTNU)
[3] Field Programmable System Level Integrated Circuit (http:/ / www. atmel. com/ products/ other/ field_programmable_gate_array/ default.
[4] Atmel Smart Card ICs (http:/ / www. atmel.com/ images/ doc1010. pdf)
[5] JTAGICE Press Release, 2004. (http:/ / atmel.com/ dyn/ corporate/ view_detail. asp?ref=& FileName=JTEGICE. html&
[6] JTAGICE3 Product Page (http:/ / www.atmel. com/ tools/ JTAGICE3. aspx)
[7] AVR ONE! Product Page (http:/ / www. atmel.com/ tools/ AVRONE_. aspx)
[8] AVR Butterfly (http:/ / www. atmel. com/ dyn/ products/ tools_card. asp?tool_id=3146)
[9] http:/ / www. avrfreaks.net/
Atmel AVR
Further reading
Embedded C Programming and the Atmel AVR; Richard H Barnett, Sarah Cox, Larry O'Cull; 560 pages; 2006;
ISBN 978-1-4180-3959-2.
C Programming for Microcontrollers Featuring ATMEL's AVR Butterfly and WinAVR Compiler; Joe Pardue; 300
pages; 2005; ISBN 978-0-9766822-0-2.
Atmel AVR Microcontroller Primer : Programming and Interfacing; Steven F Barrett, Daniel Pack, Mitchell
Thornton; 194 pages; 2007; ISBN 978-1-59829-541-2.
Arduino : A Quick Start Guide; Maik Schmidt; 276 pages; 2011; ISBN 978-1-934356-66-1.
External links
Primary Sources
Atmel AVR homepage (http:/ / www. atmel. com/ products/ avr/ )
AVR-Libc homepage (http:/ / www. nongnu. org/ avr-libc/ )
AVR Freaks community (http:/ / www. avrfreaks. net/ )
Atmel AVR Serial Port Programmer (http:/ / microembeded. blogspot. com/ 2011/ 04/
avr-serial-port-programmer. html)
Arduino community (http:/ / www. arduino. cc/ )
Atmel AVR (http:/ / www. dmoz. org/ Computers/ Hardware/ Components/ Processors/ AVR/ / ) at the Open
Directory Project, numerous AVR links
Why you need a clock source for the AVR? (http:/ / www. avrfreaks. net/ index. php?module=FreaksArticles&
func=downloadArticle& id=21)
AVR Basics (http:/ / www. robotplatform. com/ knowledge/ AVR Basics/ avr_basics. html) - AVR guide for
Simplest AVR programmer Using LPT Port (http:/ / makecircuits. com/ blog/
2009-03-23-simplest-atmega8-programmer-using-lpt-port. html)
Atmega8 Breadboard Tutorial (http:/ / www. protostack. com/ blog/ 2009/ 07/
atmega8-breadboard-circuit-part-2-of-3-the-microcontroller/ )
AVR DIP-Package Pinout Diagrams: ATtiny44/45/84/85 (http:/ / www. flickr. com/ photos/ 28521811@N04/
8451023182/ sizes/ l/ in/ photostream/ ), ATmega328P (http:/ / www. pighixxx. com/ pgdev/ Temp/
arduino_atmega328_Web. png), ATmega644P (http:/ / www. flickr. com/ photos/ 28521811@N04/ 8449933887/
sizes/ l/ in/ photostream/ ), ATmega1284P (http:/ / www. flickr. com/ photos/ 28521811@N04/ 8451021230/
sizes/ l/ in/ photostream/ )
AVR TQFP-Package Pinout Diagrams: ATmega328 (http:/ / www. flickr. com/ photos/ 28521811@N04/
8449935217/ sizes/ l/ in/ photostream/ ), ATmega2560 (http:/ / www. flickr. com/ photos/ 28521811@N04/
8451021492/ sizes/ l/ in/ photostream/ ), ATmega32U4 (http:/ / www. flickr. com/ photos/ 28521811@N04/
8467610175/ sizes/ l/ in/ photostream/ )
Atmel AVR instruction set
Atmel AVR instruction set
The Atmel AVR instruction set is the machine language for the Atmel AVR, a modified Harvard architecture 8-bit
RISC single chip microcontroller which was developed by Atmel in 1996. The AVR was one of the first
microcontroller families to use on-chip flash memory for program storage.
Processor registers
There are 32 general-purpose 8-bit registers, R0R31. All arithmetic operations operate on registers; only load and
store instructions access RAM.
The general-purpose registers are mapped to the first 32 bytes of RAM. The next 64-bytes of RAM are used for a
number of special-purpose registers. This I/O space has special addressing capabilities, so addresses within it are
often written as "0x00 (0x20)" through "0x3F (0x5F)" to show both the 6-bit I/O space address and the general RAM
Additional I/O registers may be located beginning at address 96, and general-purpose RAM begins after that.
A limited number of instructions operate on register pairs. The higher-numbered register of the pair is the most
The last six registers are used as register pairs for memory addressing. When paired, they are known as X
(R27:R26), Y (R29:R28) and Z (R31:R30). Postincrement and predecrement addressing modes are supported on all
three. Y and Z also support a six-bit displacement.
Some instructions, generally those which allow an eight-bit immediate value, are limited to registers R16R31. A
few (late additions to the instruction set) are limited to eight registers, R16 through R23.
Additional special-purpose registers are:
16- or 22-bit program counter
8-bit status register (I/O register 0x3F (0x5F))
16-bit stack pointer (I/O registers 0x3E:0x3D (0x5E:0x5D))
8-bit EIND register (I/O register 0x3C (0x5C)), high bits of Z register for indirect branches
8-bit RAMPZ register (I/O register 0x3B (0x5B)), high bits of Z register for LPM instructions
Except for the program counter, the processor special-purpose registers are also mapped to RAM, in the I/O space.
The status register bits are:
C Carry flag. This is a borrow flag on subtracts.
2. Z Zero flag. Set to 1 when an arithmetic result is zero.
3. N Negative flag. Set to a copy of the most significant bit of an arithmetic result.
4. V Overflow flag. Set in case of two's complement overflow.
5. S Sign flag. Unique to AVR, this is always NV, and shows the true sign of a comparison.
6. H Half carry. This is an internal carry from additions and is used to support BCD arithmetic.
7. 7. T Bit copy. Special bit load and bit store instructions use this bit.
8. I Interrupt flag. Set when interrupts are enabled.
Atmel AVR instruction set
Instruction timing
Arithmetic operations work on registers R0-R31 but not directly on RAM and take one clock cycle, except for
multiplication and word-wide addition (ADIW and SBIW) which take two cycles.
RAM and I/O space can be accessed only by copying to or from registers. Indirect access (including optional
postincrement, predecrement or constant displacement) is possible through registers X, Y, and Z. All accesses to
RAM takes two clock cycles. Moving between registers and I/O is one cycle. Moving eight or sixteen bit data
between registers or constant to register is also one cycle. Reading program memory (LPM) takes three cycles.
Instruction list
Instructions are 16 bits long, with some instructions requiring an additional 16-bit word for a large displacement.
"K6" refers to a 6-bit unsigned constant.
There are two types of conditional branches: jumps to address and skips. Conditional branches (BRxx) can test an
ALU flag and jump to specified address. Skips (SBxx) test an arbitrary bit in a register or I/O and skip the next
instruction if the test was true.
AVR instruction set
Arithmetic Bit & Others Transfer Jump Branch Call
ADD Rd, Rr
ADC Rd, Rr
ADIW Rd+1:Rd,
SUB Rd, Rr
SBC Rd, Rr
SBIW Rd+1:Rd,
AND Rd, Rr
OR Rd, Rr
ORI Rd, K8
EOR Rd, Rr
CP Rd, Rr
CPC Rd, Rr
CPI Rd, K8
SBI A, b
CBI A, b
BST Rd, b
BLD Rd, b
MOV Rd, Rr
MOVW Rd+1:Rd,
IN Rd, A
LDI Rd, K8
LDS Rd, K16
LD Rd, X
LD Rd, -X
LD Rd, X+
LDD Rd, Y+K6
LD Rd, -Y
LD Rd, Y+
LDD Rd, Z+K6
LD Rd, -Z
LD Rd, Z+
STS K16, Rr
ST X, Rr
ST -X, Rr
ST X+, Rr
STD Y+K6, Rr
ST -Y, Rr
ST Y+, Rr
STD Z+K6, Rr
ST -Z, Rr
ST Z+, Rr
LPM Rd, Z+
SBRC Rr, b
SBRS Rr, b
BRBC s, K7
BRBS s, K7
Atmel AVR instruction set
MUL Rd, Rr
Instruction set inheritance
Not all instructions are implemented in all Atmel AVR controllers. This is the case of the instructions performing
multiplications, extended loads/jumps/calls, long jumps, and power control.
Family Members Arithmetic Branches Transfers Bit-Wise
Minimal Core AT90S1200
LPM (not in AT90S1200)
Atmel AVR instruction set
Classic Core up
to 8K Program
new instructions:
new instructions:
new instructions:
LD (now 9 modes)
ST (9 modes)
(nothing new)
Classic Core
with up to 128K
(nothing new) new instructions:
new instructions:
(nothing new)
Enhanced Core
with up to 8K
new instructions:
(nothing new) new instructions:
LPM (3 modes)
(nothing new)
Enhanced Core
with up to 128K
(nothing new) (nothing new) (nothing new) new instructions:
Atmel AVR instruction set
Enhanced Core
with up to 4M
(nothing new) new instructions:
(nothing new) (nothing new)
XMEGA core ATxmega
new instructions:
(nothing new) new instructions:
(from second revision
silicon - AU,B,C parts)
(nothing new)
Reduced Core ATtiny10
(Identical to minimal
core, except for reduced
CPU register set)
(Identical to classic core
with up to 8K, except for
reduced CPU register set)
Identical to classic core
with up to 8K, with the
following exceptions:
LPM (removed)
LDD (removed)
STD (removed)
LD (also accesses
program memory)
LDS (different bit
STS (different bit pattern)
Reduced CPU register set
(Identical to enhanced core
with up to 128K, except for
reduced CPU register set)
Instruction encoding
Bit assignments:
rrrrr = Source register
rrrr = Source register pair
ddddd = Destination register
dddd = Destination register pair
hhhh = High register, R16R31
pp = Register pair, W, X, Y or Z
y = Y/Z register pair bit (0=Z, 1=Y)
s = Store/load bit (0=load, 1=store)
c = Call/jump (0=jump, 1=call)
aaaaaa = I/O space address
aaaaa = I/O space address (first 32 only)
bbb = Bit number
B = Bit value
kkkkkk = 6-bit unsigned constant
KKKKKKKK = 8-bit constant
The Atmel AVR uses many split fields, where bits are not contiguous in the instruction word. The load/store with
offset instructions are the most extreme example where a 6-bit offset is broken into three pieces.
Atmel AVR instruction set
Atmel AVR instruction set overview
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 Instruction
0 0 0 0 0 0 0 1 d d d d r r r r MOVW Move register pair
0 0 0 0 0 0 1 d d d r r r Signed and fractional multiply (R16R23 only)
0 0 0 0 0 1 r d d d d d r r r r 2-operand instructions
0 0 0 0 1
0 0 0 1
0 0 1 0
0 0 1 1 K K K K h h h h K K K K Register-immediate instructions
0 1
1 0 k 0 k k s d d d d d y k k k LDD/STD to Z+k or Y+k
1 0 0 1 0 0 s d d d d d LD/ST other
1 0 0 1 0 1 0 d d d d d 0 1-operand instructions (COM, NEG, SWAP, etc.)
1 0 0 1 0 1 0 0 B b b b 1 0 0 0 SEx/CLx Status register clear/set bit
1 0 0 1 0 1 0 1 1 0 0 0 Misc instructions (RET, RETI, SLEEP, etc.)
1 0 0 1 0 1 0 c 0 0 0 1 0 0 1 Indirect jump/call to Z or EIND:Z
1 0 0 1 0 1 0 d d d d d 1 0 1 0 DEC Rd
1 0 0 1 0 1 0 0 k k k k 1 0 1 1 DES round k
1 0 0 1 0 1 0 k k k k k 1 1 c k JMP/CALL abs22
1 0 0 1 0 1 1 k k p p k k k k ADIW/SBIW Rp,uimm6
1 0 0 1 1 0 B a a a a a b b b I/O space bit operations
1 0 0 1 1 1 r d d d d d r r r r MUL, unsigned: R1:R0 = RrRd
1 0 k 0 k k s d d d d d y k k k See 10k0 above
1 0 1 1 s a a d d d d d a a a a OUT/IN to I/O space
1 1 0 c 12 bit signed offset Relative jump/call to PC 2simm12
1 1 1 0 K K K K h h h h K K K K LDI Rh,K
1 1 1 1 0 B 7-bit signed offset b b b Conditional branch on status register bit
1 1 1 1 1 0 s d d d d d 0 b b b BLD/BST register bit to STATUS.T
1 1 1 1 1 1 B d d d d d 0 b b b SBRC/SBRS skip if register bit equals B
External links
GNU Development Environment
Programming the AVR microcontroller with GCC
by Guido Socher
A GNU Development Environment for the AVR Microcontroller
by Rich Neswold
AVR Options
Atmel AVR instruction set PDF(155 pages)
Atmel AVR instruction set
[1] http:/ / users.rcn. com/ rneswold/ avr/
[2] http:/ / www. linuxfocus. org/ English/ November2004/ article352. shtml
[3] http:/ / gcc.gnu.org/ onlinedocs/ gcc-3.3.5/ gcc/ AVR-Options. html
[4] http:/ / www. atmel. com/ dyn/ resources/ prod_documents/ DOC0856. PDF
Orthogonal instruction set
In computer engineering, an orthogonal instruction set is an instruction set architecture where all instruction types
can use all addressing modes. It is "orthogonal" in the sense that the instruction type and the addressing mode vary
independently. An orthogonal instruction set does not impose a limitation that requires a certain instruction to use a
specific register.
Orthogonality in practice
In many CISC computers, an instruction could access either registers or memory, usually in several different ways.
This made the CISC machines easier to program, because rather than being required to remember thousands of
individual instruction opcodes, an orthogonal instruction set allowed a programmer to instead remember just thirty to
a hundred operation codes ("ADD", "SUBTRACT", "MULTIPLY", "DIVIDE", etc.) and a set of three to ten
addressing modes ("FROM REGISTER 0", "FROM REGISTER 1", "FROM MEMORY", etc.). The DEC PDP-11
and Motorola 68000 computer architectures are examples of nearly orthogonal instruction sets, while the ARM11
and VAX are examples of CPUs with fully orthogonal instruction sets.
The PDP-11
With the exception of its floating point instructions, the PDP-11 was very strongly orthogonal. Every integer
instruction could operate on either 1-byte or 2-byte integers and could access data stored in registers, stored as part
of the instruction, stored in memory, or stored in memory and pointed to by addresses in registers. Even the PC and
the stack pointer could be affected by the ordinary instructions using all of the ordinary data modes. In fact,
"immediate" mode (hardcoded numbers within an instruction, such as ADD #4, R1 (R1 = R1 + 4) was implemented
as the mode "register indirect, autoincrement" and specifying the program counter (R7) as the register to use
reference for indirection and to autoincrement.
Since the PDP-11 was an octal-oriented (3-bit sub-byte) machine (addressing modes 0 - 7, registers R0 - R7), there
were (electronically) 8 addressing modes. Through the use of the Stack Pointer (R6) and Program Counter (R7) as
referenceable registers, there were 10 conceptual addressing modes available.
The VAX-11
The VAX-11 extended the PDP-11's orthogonality to all data types, including floating point numbers (although
instructions such as 'ADD' was divided into data-size dependent variants such as ADDB, ADDW, ADDL, ADDP,
ADDF for add byte, word, longword, packed BCD and single-precision floating point, respectively). Like the
PDP-11, the Stack Pointer and Program Counter were in the general register file (R14 and R15).
The general form of a VAX 11 instruction would be:
opcode [ operand ] [ operand ] ...
Each component being one byte, the opcode a value in the range 0 - 255, and each operand consisting of two nibbles,
the upper 4 bits specifying an addressing mode, and the lower 4 bits (usually) specifying a register number (R0 -
Orthogonal instruction set
Unlike the octal-oriented PDP-11, the VAX-11 was a hexadecimal-oriented machine (4-bit sub-byte). This resulted
in 16 logical addressing modes (0-15), however, addressing modes 0-3 were "short immediate" for immediate data of
6 bits or less (the 2 low-order bits of the addressing mode being the 2 high-order bits of the immediate data, when
prepended to the remaining 4 bits in that data-addressing byte). Since addressing modes 0-3 were identical, this made
13 (electronic) addressing modes, but as in the PDP-11, the use of the Stack Pointer (R14) and Program Counter
(R15) created a total of over 15 conceptual addressing modes (with the assembler program translating the source
code into the actual stack-pointer or program-counter based addressing mode needed).
The MC68000
Motorola's designers attempted to make the assembly language orthogonal while the underlying machine language
was somewhat less so. Unlike PDP-11, the MC68000 used separate registers to store data and the addresses of data
in memory.
At the bit level, the person writing the assembler (or debugging machine code) would clearly see that symbolic
instructions could become any of several different op-codes. This compromise gave almost the same convenience as
a truly orthogonal machine, and yet also gave the CPU designers freedom to use the bits in the instructions more
efficiently than a purely orthogonal approach might have.
The 8080 and follow on designs
The 8-bit Intel 8080 (as well as the 8085 and 8051) microprocessor was basically a slightly extended
accumulator-based design and therefore not orthogonal. An assembly-language programmer or compiler writer had
to be mindful of which operations were possible on each register: Most 8-bit operations could be performed only on
the 8-bit accumulator (the A-register), while 16-bit operations could be performed only on the 16-bit
pointer/accumulator (the HL-register pair), whereas simple operations, such as increment, were possible on all seven
8-bit registers. This was largely due to a desire to keep all opcodes one byte long and to maintain source code
compatibility with the original Intel 8008 (an LSI-implementation of the Datapoint 2200's CPU).
The binary-compatible Z80 later added prefix-codes to escape from this 1-byte limit and allow for a more powerful
instruction set. The same basic idea was employed for the Intel 8086, although, to allow for more radical extensions,
binary-compatibility with the 8080 was not attempted here; instead the 8086 was designed as a more regular and
fully 16-bit processor that was source-compatible with the 8008, 8080, and 8085. It maintained some degree of
non-orthogonality for the sake of high code density (even though this was derided as being "baroque" by some
computer scientists at the time). The 32-bit extension of this architecture that was introduced with the 80386, was
somewhat more orthogonal despite keeping all the 8086 instructions and their extended counterparts. However, the
encoding-strategy used still shows many traces from the 8008 and 8080 (and Z80); for instance, single-byte
encodings remain for certain frequent operations such as push and pop of registers and constants, and the primary
accumulator, eax, employ shorter encodings than the other registers on certain types of operations; observations like
this are sometimes exploited for code optimization in both compilers and hand written code.
Orthogonal instruction set
Into the RISC age
A fully orthogonal architecture may not be the most "bit efficient" architecture. In the late 1970s research at IBM
(and similar projects elsewhere) demonstrated that the majority of these "orthogonal" addressing modes were ignored
by most programs. Perhaps some of the bits that were used to express the fully orthogonal instruction set could
instead be used to express more virtual address bits or select from among more registers.
In the RISC age, computer designers strove to achieve a balance that they thought better. In particular, most RISC
computers, while still being highly orthogonal with regard to which instructions can process which data types, now
have reverted to "load/store" architectures. In these architectures, only a very few memory reference instructions can
access main memory and only for the purpose of loading data into registers or storing register data back into main
memory; only a few addressing modes may be available, and these modes may vary depending on whether the
instruction refers to data or involves a transfer of control (jump). Conversely, data must be in registers before it can
be operated upon by the other instructions in the computer's instruction set. This trade off is made explicitly to
enable the use of much larger register sets, extended virtual addresses, and longer immediate data (data stored
directly within the computer instruction).
Open-source hardware
The OSHW (Open Source Hardware) logo
silkscreened on an unpopulated PCB
Open-source hardware consists of physical artifacts of technology
designed and offered by the open design movement. Both free and
open-source software (FOSS) as well as open-source hardware is
created by this open-source culture movement and applies a like
concept to a variety of components. The term usually means that
information about the hardware is easily discerned. Hardware design
(i.e. mechanical drawings, schematics, bills of material, PCB layout
data, HDL source code and integrated circuit layout data), in addition
to the software that drives the hardware, are all released with the FOSS
Since the rise of reconfigurable programmable logic devices, sharing
of logic designs has been a form of open-source hardware. Instead of the schematics, hardware description language
(HDL) code is shared. HDL descriptions are commonly used to set up system-on-a-chip systems either in
field-programmable gate arrays (FPGA) or directly in application-specific integrated circuit (ASIC) designs. HDL
modules, when distributed, are called semiconductor intellectual property cores, or IP cores.
Open-source hardware
The RepRap general-purpose 3D printer with the
ability to make copies of most of its own
structural parts
Rather than creating a new license, some open-source hardware
projects simply use existing, free and open-source software licenses.
Additionally, several new licenses have been proposed. These licenses
are designed to address issues specific to hardware designs.
In these
licenses, many of the fundamental principles expressed in open-source
software (OSS) licenses have been "ported" to their counterpart
hardware projects. Organizations tend to rally around a shared license.
For example, Opencores prefers the LGPL or a Modified BSD
FreeCores insists on the GPL,
Open Hardware
Foundation promotes "copyleft" or other permissive licenses",
Open Graphics Project uses a variety of licenses, including the MIT
license, GPL, and a proprietary license,
and the Balloon Project
wrote their own license.
New hardware licenses are often explained as the "hardware equivalent" of a well-known
OSS license, such as the GPL, LGPL, or BSD license.
Despite superficial similarities to software licenses, most hardware licenses are fundamentally different: by nature,
they typically rely more heavily on patent law than on copyright law. Whereas a copyright license may control the
distribution of the source code or design documents, a patent license may control the use and manufacturing of the
physical device built from the design documents. This distinction is explicitly mentioned in the preamble of the
TAPR Open Hardware License:
"... those who benefit from an OHL design may not bring lawsuits claiming that design infringes their patents
or other intellectual property."
TAPR Open Hardware License,
Noteworthy licenses include:
The TAPR Open Hardware License: drafted by attorney John Ackermann, reviewed by OSS community leaders
Bruce Perens and Eric S. Raymond, and discussed by hundreds of volunteers in an open community discussion
Balloon Open Hardware License: used by all projects in the Balloon Project
Although originally a software license, OpenCores encourages the LGPL
Hardware Design Public License: written by Graham Seaman, admin. of Opencollector.org
In March 2011 CERN released the CERN Open Hardware License (OHL) intended for use with the Open
Hardware Repository
and other projects.
The Solderpad License is a version of the Apache License version 2.0, amended by lawyer Andrew Katz to render
it more appropriate for hardware use.
Open-source hardware
The Arduino Diecimila
Extensive discussion has taken place on ways to make open-source
hardware as accessible as open-source software. Discussions focus on
multiple areas,
such as the level at which open-source hardware is
ways to collaborate in hardware development, as well as a
model for sustainable development by making open-source appropriate
In addition there has been considerable work to
produce open-source hardware for scientific hardware using a
combination of open-source electronics and 3-D printing.
One of the major differences between developing open-source software
and developing open-source hardware is that hardware results in
tangible outputs, which cost money to prototype and manufacture. As a result, the phrase "free as in speech, not as in
more formally known as Gratis versus Libre, distinguishes between the idea of zero cost and the freedom
to use and modify information. While open-source hardware faces challenges in minimizing cost and reducing
financial risks for individual project developers, some community members have proposed models to address these
Given this, there are initiatives to develop sustainable community funding mechanisms, such as the Open
Source Hardware Central Bank,
as well as tools like KiCad to make schematic development more accessible to
more users.
Often vendors of chips and other electronic components will sponsor contests with the proviso that the participants
and winners must share their designs. Circuit Cellar magazine organizes some of these contests.
Open source labs
Examples of open source labs include:
Boston Open Source Science Laboratory, Somerville, Massachusetts
BYU Open Source Lab, Brigham Young University
OSU Open Source Lab, Oregon State University
Open Source Research Lab, University of Texas at El Paso
Stanford Open Source Lab, Stanford University
Business models
Open hardware companies are experimenting with different business models. Arduino, for example, has registered
their name as a trademark. Others may manufacture their designs, but they can't put the Arduino name on them. Thus
they can distinguish their products from others by appellation.
There are many applicable business models for
implementing some open-source hardware even in traditional firms. For example, to accelerate development and
technical innovation the photovoltaic industry has experimented with partnerships, franchises, secondary supplier
and completely open-source models.
Open-source hardware
[1] From OpenCollector's "License Zone" (http:/ / opencollector. org/ hardlicense/ licenses. html): GPL used by Free Model Foundry and ESA
Sparc; other licenses used by Free-IP Project, LART (defunct), GNUBook (defunct).
[2] For a nearly comprehensive list of licenses, see OpenCollector's "license zone" (http:/ / opencollector. org/ hardlicense/ licenses. html)
[3] Item "What license is used for OpenCores?" (http:/ / opencores. org/ opencores,faq#whatlicense), from Opencores.org FAQ, retrieved 14
January 2013
[4] FreeCores Main Page (http:/ / www. freecores.org/ wiki/ Main_Page), retrieved 25 November 2008
[5] Open Hardware Foundation, main page (http:/ / www.linuxfund. org/ projects/ ogd1/ ), retrieved 25 November 2008
[6] See "Are we going to get the 'source' for what is on the FPGA also?" in the Open Graphics Project FAQ (http:/ / wiki. opengraphics. org/
tiki-index.php?page=FrequentlyAskedQuestions), retrieved 25 November 2008
[7] Balloon License (http:/ / balloonboard.org/ licence.html), from balloonboard.org
[8] TAPR Open Hardware License (http:/ / www.tapr.org/ ohl. html)
[9] transcript of all comments (http:/ / technocrat. net/ d/ 2007/ 2/ 5/ 14355), hosted on technocrat.net
[10] Open Hardware Repository (http:/ / www.ohwr.org/ )
[11] (http:/ / www. opencollector. org/ Whyfree/ ), Writings on Open Source Hardware
[12] (http:/ / blog.makezine. com/ archive/ 2007/ 04/ open_source_hardware_what. html) MAKE: Blog: Open source hardware, what is it?
Here's a start...
[13] (http:/ / www. halfbakery. com/ idea/ Open_20Source_20Hardware_20Initiative), Halfbakery: Open Source Hardware Initiative
[14] J. M Pearce, C. Morris Blair, K. J. Laciak, R. Andrews, A. Nosrat and I. Zelenika-Zovko, "3-D Printing of Open Source Appropriate
Technologies for Self-Directed Sustainable Development", Journal of Sustainable Development 3(4), pp. 17-29 (2010) (http:/ / www. ccsenet.
org/ journal/ index.php/ jsd/ article/ view/ 6984)
[15] Pearce, Joshua M. 2012. " Building Research Equipment with Free, Open-Source Hardware. (http:/ / www. sciencemag. org/ content/ 337/
6100/ 1303.summary)" Science 337 (6100): 13031304. open access (http:/ / mtu. academia. edu/ JoshuaPearce/ Papers/ 1867941/
[16] (http:/ / www. wired. com/ wired/ archive/ 14.09/ posts.html?pg=6)"Free, as in Beer", by Lawrence Lessig, Wired
[17] (http:/ / pages.nyu. edu/ ~gmp216/ papers/ bmfosh-1.0.html), Business Models for Open Source Hardware Design
[18] Open Source Hardware Central Bank (http:/ / blog.makezine. com/ archive/ 2009/ 03/ the_open_source_hardware_bank. html), from
"Make: Online : The Open Source Hardware Bank, retrieved 26 April 2010
[19] Clive Thompson, "Build It. Share It. Profit. Can Open Source Hardware Work?", Wired Magazine, October 2008 (http:/ / www. wired. com/
techbiz/ startups/ magazine/ 16-11/ ff_openmanufacturing?currentPage=all)
[20] A. J. Buitenhuis and J. M. Pearce, " Open-Source Development of Solar Photovoltaic Technology (http:/ / dx. doi. org/ 10. 1016/ j. esd.
2012. 06.006)", Energy for Sustainable Development, 16, pp. 379-388 (2012). open access (http:/ / mtu. academia. edu/ JoshuaPearce/ Papers/
1886844/ Open-Source_Development_of_Solar_Photovoltaic_Technology)
External links
Open Circuits wiki (http:/ / opencircuits. com/ Main_Page)
Open Source Semiconductor Core Licensing, 25 Harvard Journal of Law & Technology 131 (2011) (http:/ / jolt.
law. harvard. edu/ articles/ pdf/ v25/ 25HarvJLTech131. pdf)
Definition of Open source hardware (http:/ / freedomdefined. org/ OSHW), freedomdefined.org
P2P Foundation: Open Hardware Directory (http:/ / p2pfoundation. net/ Product_Hacking)
Database of Open-source hardware writings (http:/ / www. opencollector. org/ Whyfree/ ), Open Collector
Open Source Everywhere (http:/ / www. wired. com/ wired/ archive/ 11. 11/ opensource. html), Wired
Build It. Share It. Profit. Can Open Source Hardware Work? (http:/ / www. wired. com/ techbiz/ startups/
magazine/ 16-11/ ff_openmanufacturing), Wired
Richard Stallman: On "Free Hardware" (http:/ / www. linuxtoday. com/ infrastructure/ 1999062200505NWLF),
Open Sesame! (http:/ / www. economist. com/ science/ tq/ displaystory. cfm?story_id=11482589) (Reports), The
Business models for Open Hardware (http:/ / www. openp2pdesign. org/ 2011/ open-design/
business-models-for-open-hardware/ )
oshug.org (http:/ / oshug. org) Open Source Hardware User Group
Open Source Hardware and Design Alliance (http:/ / www. ohanda. org/ )
Open Source CNC Hardware Community (http:/ / www. cncmentor. com/ ?q=node/ )
Open-source hardware
Open Source Hardware: An Introductory Approach (http:/ / www. lap-publishing. com/ catalog/ details/ / store/
gb/ book/ 978-3-659-46591-8/ open-source-hardware:-an-introductory-approach/ )
List of Arduino compatibles
This is a non-exhaustive list of Arduino boards and compatible systems. It lists boards in these categories:
Released under the official Arduino name
Arduino "shield" compatible
Development-environment compatible
Based on non-Atmel processors
Where different from the Arduino base feature set, compatibility, features, and licensing details are included.
Official Arduino versions
Many versions of the official Arduino hardware have been commercially produced to date:
Name Processor Format Host interface I/O Release
Processor Frequency Dimensions Voltage Flash
Atmega32u4 16MHz Arduino 70003400000000000002.72.1in
[68.6 53.3mm]
USB 32u4 5V 32 1 2.5 14 6 12 July 23,
The Leonardo
uses the
which has a
USB controller
eliminating one
chip as
compared to
List of Arduino compatibles
ATmega328P 16MHz Arduino 70003400000000000002.72.1in
[68.6 53.3mm]
5V 32 1 2 14 6 6 September
24, 2010
This uses the
ATmega328 as
but whereas the
used an FTDI
chipset for
USB, the Uno
uses an
before rev3)
programmed as
a serial
84MHz Mega 700045000000000000042.1in
[101.6 53.3mm]
USB 16U2 +
native host
3.3V 512 0 96 54 12 12 October
22, 2012
The first
Arduino board
based on an
Features 2
channel 12-bit
DAC, 84Mhz
512KB Flash
and 96KB
SRAM. Unlike
most arduino
boards, it
operates on
3.3V and is
not 5V
List of Arduino compatibles
ATmega2560 16MHz Mega 700045000000000000042.1in
[101.6 53.3mm]
5V 256 4 8 54 14 16 September
24, 2010
Total memory
of 256kB.
Uses the
before Rev3)
USB chipset.
Most shields
that were
designed for
Diecimila, or
Uno will fit,
but a few
shields will not
fit because of
with the extra
ATmega328 16MHz Arduino 70003400000000000002.72.1in
[68.6 53.3mm]
5V 32 1 2 14 4 6 July 13,
Based on the
same WIZnet
W5100 chipset
as the Arduino
Shield. A serial
interface is
provided for
but no USB
interface. Late
versions of this
board support
Power over
Ethernet (PoE).
List of Arduino compatibles
ATmega328P 8MHz minimal 70002800000000999992.61.1in
[66.0 27.9mm]
3.3V 32 1 2 14 6 8 March 18,
Includes XBee
socket on
bottom of
before version
16MHz minimal 70001900000000000001.70 0.73in
[43.18 18.54mm]
USB FTDI 5V 16/32 0.5/1 1/2 14 6 8 May 15,
This small
version of the
Arduino uses a
8MHz wearable 70002000000000000002in51mm 2.7-5.5V 16 0.5 1 14 6 6 October
17, 2007
design is for
ATmega2560 16MHz Mega 700045000000000000042.1in
[101.6 53.3mm]
USB Host
5V 256 4 8 54 14 16 July 13,
List of Arduino compatibles
Atmega32u4 16MHz 70006900000000000006.52.4in
[165.1 61.0mm]
32u4 5V 32 1 2.5 December
10, 2012
joystick, four
buttons, several
sensors, 2
inputs and 2
outputs, LCD
ATmega32u4 16MHz 70002000000000000000.71.9in
[17.8 48.3mm]
5V 32 1 2.5 20 7 12 November
8, 2012
(Pro) Mini
(Pro uses
or 16MHz
[17.8 33.0mm]
5V or
16 0.5 1 14 6 6 August
23, 2008
This miniature
version of the
Arduino uses a
Superseded versions
The following have been superseded by later and more capable versions from Arduino, but some, particularly the
Duemilanove, are still in widespread use.
Name Processor Format Host interface I/O Release
Processor Frequency Dimensions Voltage Flash
ATmega8 16MHz Arduino 70003800000000000003.22.1in
[81.3 53.3mm]
The first board
List of Arduino compatibles
ATmega8 16MHz Arduino 70003800000000000003.22.1in
[81.3 53.3mm]
Changed: USB
Arduino can be
powered from
ATmega8 16MHz Arduino 70003800000000000003.22.1in
[81.3 53.3mm]
USB The Arduino
Extreme uses
many more
surface mount
than previous
USB Arduino
boards and
comes with
female pin
Arduino NG
ATmega8 16MHz Arduino 70003800000000000003.22.1in
[81.3 53.3mm]
FT232BM has
been replaced
by FT232RL to
require fewer
LED on pin 13
Arduino NG
ATmega168 16MHz Arduino 70003800000000000003.22.1in
[81.3 53.3mm]
Arduino BT
16MHz Arduino 70003800000000000003.22.1in
[81.3 53.3mm]
Bluetooth Bluegiga
5V 32 1 2 14 4 6 October
Similar to the
Arduino NG,
this has a
module rather
than a serial
is carried out
via Bluetooth.
List of Arduino compatibles
ATmega168 in a
DIL28 package
16MHz Arduino 70003400000000000002.72.1in
[68.6 53.3mm]
USB FTDI 5V 16 0.5 1 14 6 6 October
Improved: Host
is able to reset
the Arduino,
pin headers for
reset and 3.3V,
low dropout
allows lower
voltage on
external power
(ATmega328 for
newer version)
16MHz Arduino 70003400000000000002.72.1in
[68.6 53.3mm]
USB FTDI 5V 16/32 0.5/1 1/2 14 6 6 October
between USB
and external
ATmega1280 16MHz Mega 700045000000000000042.1in
[101.6 53.3mm]
USB FTDI 5V 128 4 8 54 14 16 March
Uses a
for additional
I/O and
Arduino-compatible boards
Although the hardware and software designs are freely available under copyleft licenses, the developers have
requested that the name "Arduino" be exclusive to the official product and not be used for derivative works without
permission. The official policy document on the use of the Arduino name emphasizes that the project is open to
incorporating work by others into the official product.
As a result of the protected naming conventions of the Arduino, a group of Arduino users forked the Arduino
Diecimila, releasing an equivalent board called Freeduino. The name "Freeduino" is not trademarked and is free to
use for any purpose.
Several Arduino-compatible products commercially released have avoided the "Arduino" name by using "-duino"
name variants.
List of Arduino compatibles
Arduino footprint-compatible boards
The following boards are fully or almost fully compatible with both the Arduino hardware and software, including
being able to accept "shield" daughterboards.
Name Processor Maker Notes
AVR.duino U+ ATmega328 SlicMicro.com
Compatible With Arduino Uno Rev3
SainSmart UNO ATmega328 SainSmart
Compatible With Arduino
SainSmart Mega
ATmega2560 SainSmart
Compatible with Arduino
List of Arduino compatibles
SainSmart UNO
ATmega328-AU SainSmart
Development board compatible with Arduino
Controller: SMD MEGA328P-AU; A6/A7 port added;
3.3V/5V supply voltage and I/O voltage switch.
AVR-Duino TavIR Another Arduino/Mega compatible board.
Brasuno Holoscpio
Based on the Uno with rearranged LEDs and reset button,
mini-USB connector, and altered pin 13 circuitry so that the
LED and resistor do not interfere with pin function when
acting as an input. The Brasuno was designed using KiCad,
and is licensed as GPLv2.
ChibiDuino2 ATmega328 TiisaiDipJp Smallest and Cheapest Japanese made Arduino compatible
Kit. Board setting is "Uno". Includes two mini-B USB
socket, One for USB serial, another for 5 V USB power
supply or software USB(V-USB) connection, 1602 LCD
socket, 5V or 3.3V power selection, universal soldering
area . Small board size with many function, designed with
Japanese craftsmanship !
Cosmo Black Star ATmega328 JT5 Arduino layout-compatible board. Based on the Arduino
CraftDuino Manufactured and
sold by RoboCraft
List of Arduino compatibles
Diavolino Evil Mad Scientist
Arduino layout-compatible board, designed for use with a
USB-TTL serial cable.
DuinoBot v1.x ATmega32U4 RobotGroup
Arduino fully compatible board, with integrated power
supply and controllers designed for robotics. Compatible as
well with the system "Multiplo"
eJackino Kit by CQ publisher
in Japan.
Similar to Seeeduino, eJackino can use Universal boards as
Shields. On back side, there is a "Akihabara station" silk,
just like Italia on Arduino.
Manufactured and
sold assembled or as a
kit by Fundamental
Logic until May
A board with a standard DE-9 serial port.
Freeduino SB ATmega328 Solarbotics Ltd.
Compatible with the Duemilanove.
Manufactured and
sold as a kit by NKC
The design avoids surface-mount soldering.
ATmega644 Provides 64kB of flash, 4kB of RAM and 42 general I/O
pins. Hardware and firmware are open source.
InduinoX ATmega168/ATmega 328/ATmega 8 Simple Labs A low cost Arduino clone using the ATmega168/ATmega
328/ATmega 8 and designed for prototyping, it includes
onboard peripherals such as an RGB LED, switches, IR
Tx/Rx and DS1307(RTC).
Japanino ATmega168 A kit by Otonano
Kagaku publisher in
The board and a POV kit were included in Vol. 27 of the
eponymous series. It is unique in having a regular size USB
A connector.
1000Pads Luigino Minimalistic version of Arduino: small, without serial
converter. Available as a kit, board only or assembled.
Smaller than Arduino, with different footprint.
Luigino328 ATmega328 It has an improved automatic voltage selector, resolves
problems during programming caused by shields that use
the serial port, with an automatic serial port selector, and
has the LM1117 voltage regulator.
List of Arduino compatibles
metaboard Developed by
Metalab, a
hackerspace in
Designed to have a very low complexity and price.
Hardware and firmware are open source.
Rascal AT91SAM9G20 (ARM9 family) Rascal Micro It is compatible with Arduino shields, but it is programmed
in Python rather than C++. It has an embedded webserver.
Raspduino ATmega328 Bitwizard Fully Arduino compatible board, that fits perfectly on a
Raspberry Pi, and can be programmed through the
Raspberry Pi's serial interface. It also breaks out the
Raspberry Pi's SPI and IC interfaces, or can be used as a
stand-alone Arduino when powered with the external power
Romeo 2012 ATmega328 DFRobot An all-in-one Arduino with motor controller. Compatible
with the Arduino Uno.
Designed for robotics. All connections have neighboring
power buses (not pictured) for servos and sensors.
Additional headers for power and serial communication are
provided. It was developed by Curious Inventor, LLC.
Seeeduino v2.21 (Atmega168 or Atmega328)
v3.0 (Atmega328)
Derived from the Diecimila. This photo is v1.0b.
SunDuino ATmega8/88/168/328/16/32/324/644 and
PIC18F2550/4550 PIC32MX320F128
and ButterFLY, STM32Discovery
Lothar Team Arduino
PRO Compatible
boards. (Poland)
Another Arduino compatible board, software- and
List of Arduino compatibles
TwentyTen Freetronics
Based on the Duemilanove, with a prototyping area,
rearranged LEDs, mini-USB connector, and altered pin 13
circuitry so LED and resistor do not interfere with pin
function when acting as an input.
Volksduino Applied Platonics A low cost, high power, shield-compatible, complete
Arduino-compatible board kit. Based on the Duemilanove,
it comes with a 5V / 1A voltage regulator (optional 3.3V
regulator). Designed for low component count and for ease
of assembly.
Wiseduino Includes a DS1307 real-time clock (RTC) with backup
battery, a 24LC256 EEPROM and a connector for XBee
adapter for wireless communication.
Xaduino ATXmega128A3U http:/ / www.
obdiiworld. com/
(parts in Chinese?)
8/16 bit Xmega core @ 32MHz. 8 KB SRAM. 37 Digital
I/O. 3.3V. 2 DAC. Output 3.3V pin: 500mA, 5V
YourDuinoRobo1 Atmel 328 Yourdunio Includes 6 color-coded 3-pin connectors for direct cable
connection of servos, electronic bricks, etc., and 6 3-pin
connectors to Analog inputs for electronic bricks, etc.
Provides improved 3.3V regulator supplying 500mA, and
optional 3.3V operation.
ZArdino A South African Arduino-compatible board derived from
the Duemilanove, it features mostly through-hole
construction except for the SMD FT232RL IC, power
selection switches, option for a Phoenix power connector
instead of DC jack, extra I/O pads for using Veroboard as
shields. Designed for easy assembly in countries where
exotic components are hard to find.
Zigduino ATmega128RFA1 Logos
Integrates ZigBee (IEEE 802.15.4). It can be used with
other 802.15.4 network standards as well as ZigBee. It is
the same shape as the Duemilanove, includes an external
RPSMA jack on the side of the board opposite the power
jack, and is compatible with shields that work with other
3.3V boards.
List of Arduino compatibles
Special purpose Arduino-compatible boards
Special purpose Arduino-compatible boards add additional hardware optimised for a specific application. It is kind
of like having an Arduino and a shield on a single board. Some are Shield compatible, others are not.
Name Processor Shield-compatible? Host
Maker Additions
Io:duino AT90CAN128 yes USB with
serial chip
Railstars Adds built-in CAN support through the AT90CAN128 micro
processor, dual RJ45 jacks, and optional bus termination.
Designed specifically for model railroading applications using
the OpenLCB networking protocol, the hardware is
sufficiently generic for use with other low-speed CAN
ATmega328 The is a minimalist tracked platform based on the Arduino
Duemilanove. Has an ATmega328 with Arduino bootloader, a
dual H-bridge and additional prototyping space and headers. It
is compatible with many shields, though four digital pins are
used when operating the motor controller. Has an onboard
voltage regulator, additional LEDs, a temperature sensor, and
a light sensor. Part of the DFRobotShop Rover kit.
Faraduino ATmega328 Yes USB with
serial chip
Developed by
Simple shield-compatible board, with onboard discrete
transistor H-bridges and screw terminals to drive two small
DC motors from pins 4-7. Has headers for three servos on pins
Also sold with the Faraduino buggy kit and Faraconnect shield
as a simple school-level teaching robot.
Lightuino ATmega328p Produced as a stand-alone '328 Arduino-compatible board and
as a shield. It directly drives LEDs (70 constant-current
channels) or LED matrices (1100 LEDs), and has an
adjustable LED voltage regulator, an ambient light sensor, and
an IR receiver.
List of Arduino compatibles
Motoruino ATmega328 Yes Serial
only, 6 pin
Has L293D twin H-bridge.
ArduPilot An Arduino-compatible board designed for auto-piloting and
autonomous navigation of aircraft, cars, and boats. It uses GPS
for navigation and thermopile sensors or an IMU for
ATmega 2560 Serial
only, 6 pin
Paul Bake An Arduino Mega 2560 compatible board designed for
auto-piloting and autonomous navigation of multirotor
aircraft. Designed to be stacked with sensor bobs and boards
with several breakout boards available.
Colibri ATmega168 No Serial only JT5 Universal Platform for Wireless Data Transmission in the
Frequency Band 868MHz. The Board Combines Features
Arduino Mini and the Radio EZRadioPRO for Receiving and
Transmitting Data. With dataFlash.
JeeNode ATmega328 6 pin
Jeelabs Includes a wireless radio module, called the RFM12B by
Software-compatibility only
These boards are compatible with the Arduino software, but they do not accept standard shields. They have different
connectors for power and I/O, such as a series of pins on the underside of the board for use with breadboards for
prototyping, or more specific connectors. One of the important choices made by Arduino-compatible board designers
is whether or not to include USB circuitry in the board. That circuitry can be placed in the cable between
development PC and board, thus making each instance of the board less expensive. For many Arduino tasks, the
USB circuitry is redundant once the device has been programmed.
Name Processor Maker Notes
Ardweeny Solarbotics An inexpensive, even more compact breadboardable device.
Bare Bones Board
(BBB) and Really Bare
Bones Board (RBBB)
Modern Device Compact inexpensive Arduino-compatible board suitable for
BlockDuino ATmega8 ATmega328 Blockduino An Arduino-Diecimila-compatible board with serial connection to
Blocks (shields).
List of Arduino compatibles
Boarduino ATmega168 ATmega328 Adafruit
An inexpensive Arduino-Diecimila-compatible board made for
Breaduino Applied Platonics A complete, very low cost Arduino-compatible kit that can be
assembled entirely on a breadboard.
Croduino Basic ATmega328 e-radionica.com Inexpensive fully compatible Arduino board for schools and DIY
individuals in Croatia.
Cardboarduino ATmega168 Inspired by the Paperduino, an ultra low-cost Arduino compatible, built
on printed posterboard, rather than a PCB.
Crumbuino-Nano ATmega328 chip45.com/ The Crumbuino-Nano is a low-cost module comparable to the
Arduino-Nano and can be used as Arduino-Nano in the Arduino-IDE.
The Arduino bootloader is preloaded, hence the module is ready-to-use.
The documentation shows the pin mapping of Arduino-naming to
module pinout.
Crumbuino-Mega ATmega2560 chip45.com/ The Crumbuino-Mega is a low-cost module comparable to the
Arduino-Mega 2560 and can be used as Arduino-Mega 2560 in the
Arduino-IDE. The Arduino bootloader is preloaded, hence the module is
ready-to-use. The documentation shows the pin mapping of
Arduino-naming to module pinout.
Digispark:[2] ATTiny85 "Digistump":http:/
/ digistump. com/
Requires special version of the Arduino IDE.
DragonFly ATmega1280 A compact board with Molex connectors, aimed at environments where
vibration could be an issue. DragonFly features the ATmega1280 and
have all 86 I/O lines pinned out to connectors.
List of Arduino compatibles
Freeduino USB Mega
ATmega2560 Bhasha
Freeduino USB Mega 2560, designed in India
with Male headers (coming soon with Female
Headers). Suitable for use in project, R&D,
device and applications
Freeduino USB Mega 2560 is a cost effective and 100% pin and
software compatible to the popular Arduino Mega 2560. Uses through
hole components and has male headers.
Freeduino Lite v2 ATmega8/168/328 Bhasha
Freeduino Lite v2 is a low cost, Freeduino with no USB and Serial port.
Needs FTDI USB Cable or FTDI Breakout board for programming.
Uses through hole components and has male headers.
Freeduino Serial ATmega8/168/328 Bhasha
Freeduino Serial is a low cost Freeduino board with serial DB9
connector. Uses MAX232 Chip for Serial connectivty.
Freeduino NANO ATmega328 Bhasha
Freeduino nano designed in India, completely
breadboard friendly, elegant and compact
design..Build your project and devices using
Freeduino Nano
Freeduino Nano is a low cost Arduino Nano compatible board with mini
USB connector using SMD components Freeduino Nano
List of Arduino compatibles
Femtoduino ATmega328P-MU Femtoduino
Femtoduino PCB vs Dime
An ultra-small (20.7x15.2mm) Arduino compatible board designed by
Fabio Varesano. Femtoduino is currently the smallest Arduino
compatible board available.
[citation needed]
iDuino A USB board for breadboarding, manufactured and sold as a kit by
Fundamental Logic.
JeeNode ATmega328P JeeLabs
Low-cost, low-size, radio-enabled Arduino-compatible board running at
3.3V. Inspired by the Modern Device RBBB (above) with a HopeRF
RFM12B wireless module and a modular I/O design supporting a wide
range of interfaces.
LEDuino A board with enhanced IC, DCC decoder and CAN-bus interfaces.
Manufactured using surface mount and sold assembled by
An SD-card size wireless-enabled breadboard friendly Arduino
compatible board running at 16MHz/3.3V. It can mate with either an
RFM12B or RFM69W/HW/CW transceiver from HopeRF, allowing
very low cost wireless communication (also available without a
transceiver). Programmable from the Arduino IDE through an FTDI
cable/adapter, or directly through the USB interface (Moteino-USB
revision). Moteino runs DualOptiboot,
a custom version of Optiboot
that allows wireless programming when external FLASH memory is
NB1A An Arduino-compatible board that includes a battery backed up
real-time clock and a four channel DAC. Most Arduino-compatible
boards require an additional shield for these resources.
List of Arduino compatibles
NB2A Sanguino-compatible board that includes a battery backed up real-time
clock and a two channel DAC. Sanguino's feature the ATmega644P,
which has additional memory, I/O lines and a second UART.
Nymph ATmega328P A compact board with Molex connectors, aimed at environments where
vibration could be an issue.
Oak Micros om328p An Arduino Duemilanove compacted down to a breadboardable device
(36mm x 18mm) that can be inserted into a standard 600mil 28-pin
socket, with USB capability, ATmega328P, and 6 onboard LEDs.
OpenTag ATmega328p Loggerhead
Arduino-compatible microSD motion datalogging board with
accelerometer, magnetometer, gyroscope, pressure, temperature and
real-time clock.
Paperduino ATmega168 An ultra low-cost Arduino compatible, built on a printed paper and
cardboard substrate, rather than a PCB.
Rainbowduino An Arduino-compatible board designed specifically for driving LEDs. It
is generally used to drive an 8x8 RGB LED matrix using row scanning,
but it can be used for other things.
Sanguino ATmega644
An open source enhanced Arduino-compatible board that uses an
ATMega644P instead of an ATmega168. This provides 64kB of flash,
4kB of RAM and 32 general I/O pins in a 40 pin DIP device. It was
developed with the RepRap Project in mind.
Seeeduino Mega ATmega2560 SeeedStudio Arduino Mega compatible board with 16 extra I/O pins and the same a
board size as the Arduino Uno. As with the Arduino Mega, most shields
that were designed for the Duemilanove, Diecimila, or Uno will fit, but
a few shields will not fit because of interference with the extra pins.
List of Arduino compatibles
SODAQ, an Arduino Compatible Solar Powered
sensor board
The SODAQ board is built for Solar Powered Data Acquisition. It is
fitted with a Lipo charge controller and 12 Grove sockets for plug and
play prototyping. It runs at 3.3V and 8MHz. It also comes with a Real
Time Clock and 16 Mbit serial flash for data logging. With its bee
socket you can use a range of different bee modules, like Xbee, RFbee,
Bluetoothbee and GPRSbee to make the board communicate.
Atmega Microcontroller running at 3.3V and 8MHz
Arduino Compatible
Power supply by LiPo battery (3.7V) or USB cable
Solar charge controller with JST connector for Solar Panel up to
Battery Monitor
DS3231 Real Time Clock and Temperature sensor, clock backup
powered by LiPo battery
8 MBit data flash module (AT45DB)
Micro USB connector
12 Grove connectors connecting Digital, Analog and I2C pins
On/Off switch. With the switch in Off position the solar charge
circuit is still active and the RTC clock is still powered.
ICSP programming header
Bee socket for Xbee, GPRSbee or other bee style modules
Same size as Raspberry Pi
Sparrow ATMega328P Open Home
Arduino compatible board designed specifically for RF mesh network
experiments. It features 10 IOs, an 10 pin ISP programming connector, a
connector for a standard LCD display (in 4 bit mode) and a connector
for an 2.4Ghz RF module.
Spider Controller Arduino Mega compatible board designed specifically for robots
requiring large numbers of servos. A built in 3A switchmode power
supply allows servos to plug directly into the board. Pin spacing allows
making custom shields from standard prototype board.
Stickduino Similar to a USB key.
Teensy and Teensy++ A pair of boards from PJRC.com that run most Arduino sketches using
the Teensyduino software add-on to the Arduino IDE.
Teensy 3.0 A very small board from PJRC.com based on the Freescale
MK20DX128VLH5 32-bit ARM Cortex-M4 48MHz CPU. It has 34
I/O pins; 128 kB of flash; 16-bit ADC; UARTs, SPI, IC, Touch and
other I/O capability.
List of Arduino compatibles
TinyDuino ATmega328p TinyCircuits
A fully capable Arduino platform smaller than a quarter, yet with all the
power and functionality of the Arduino Uno board, including stackable
shield support. The TinyDuino also support an option coin cell holder
and has many expansion shields available.
TinyLily ATmega328p TinyCircuits
A fully capable Arduino platform smaller than a dime, designed for
e-textiles. Includes large sewtabs and a header for a USB adapter for
communication and programming.
Wireless Widget A compact (35mm x 70mm), low voltage, battery powered
Arduino-compatible board with onboard wireless capable of ranges up
to 120m. The Wireless Widget was designed for both portable and low
cost Wireless sensor network applications.
ZB1 An Arduino-compatible board that includes a Zigbee radio (XBee). The
ZB1 can be powered by USB, a wall adapter or an external battery
source. It is designed for low-cost Wireless sensor network applications.
SunDuino2 ATmega16/32/324/644 An open source enhanced Arduino-compatible board that uses an
ATmega16/32/324/644 instead of an ATmega168. This provides
16/32/64kB of flash, and 32 general I/O pins in a 40 pin DIP device.
An open-source low power wireless (RFM12B) energy monitoring node
based on ATmega328 and JeeNode design and uses the Nanode (another
Arduino compatible) design for their receiver.
List of Arduino compatibles
panStamp ATmega328 panStamp
Small low-power wireless motes and base boards. Communication
library, configuration tools and automation applications are available for
panStamps. These wireless miniatures can easily be hooked to different
cloud data services via Lagarto, an open automation platform developed
for panStamps.
Microduino ATmega168/328/644/1284 Microduino Studio 1" x 1.1" small, stackable, low-cost Arduino-compatible board with a
uniformed U-shape 27-pin standard interface. Bring flexibility and clean
profile to your Arduino projects.
Non-ATmega boards
The following non-ATmega boards accept Arduino shield daughter boards. The microcontrollers are not compatible
with the official Arduino IDE, but they do provide a version of the Arduino IDE and compatible software libraries.
Name Processor Host
Maker Notes
ARM STM32 USB LeafLabs
A 72MHz 32-bit ARM Cortex-M3-based microcontroller (ST
Microelectronics] STM32F103) with USB support, compatibility with
Arduino shields, and 39 GP I/O pins. Programmable with the Open Source
Maple IDE, which is a branch of the Arduino IDE. The Maple IDE includes
both an implementation of the Arduino Language, and lower-level native
libraries (with support from the libmaple C library).
Uno32 and
PIC32 USB Digilent 32-bit MIPS-M4K PIC32 processor boards. The Arduino libraries have been
implemented natively for the PIC32 and these kits run in a fork of the
standard Arduino IDE, chipKIT32-MAX and are compatible to most shields.
Kinetis-L ARM
USB Freescale A 48MHz 32-bit ARM Cortex-M0+-based microcontroller (Freescale
MKL25Z128VLK4) with USB support, compatibility with Arduino shields
and 64 GP I/O pins. Board embeds the new ARM OpenSDA debug and
programming interface through USB and is compatible with the majority of
the ARM IDE suppliers.
List of Arduino compatibles
PRO Family ARM Cortex
USB Coridium up to 100MHz ARM Cortex-M3 and ARM7TDMI-based shield-compatible
boards, programmable in BASIC or C with Sketch support with open source
MakeItC utilities. All boards have 5 V tolerant IOs.
Energia MSP430 USB Texas Instruments The Energia project integrates this with the Arduino IDE.
Sakura board Renesas
USB Renesas/Wakamatsu
Tsusho Co.,Ltd
Web compiler with Sketch support, ethernet interface
Non-Arduino boards
The following boards accept Arduino shield daughter boards. They do not use ATmega microcontrollers and so are
not compatible with the Arduino IDE, nor do they provide an alternative implementation of the Arduino IDE and
software libraries.
Name Processor Maker Notes
Arduino Shield
Propeller Board
Parallax Based on the Parallax Propeller; interfaces with standard Arduino shields. The
Propeller comes with a free IDE called "propeller tool", and an alternative IDE tool
is available.
Amicus18 PIC Amicus18 is an embedded system platform based on PIC architecture (18F25K20).
Can be programmed with any programming language, though the Amicus IDE is
free and complete.
Cortino ARM STM32 Development system for a 32-bit ARM Cortex-M3-based microcontroller.
Pinguino PIC Board based on a PIC microcontroller, with native USB support and compatibility
with the Arduino programing language plus an IDE built with Python and sdcc as
Unduino PIC A board based on the dsPIC33FJ128MC202 microcontroller, with integrated motor
control peripherals.
Netduino ARM
48MHz 32-bit ARM7 microcontroller board with support for the .NET Micro
Framework. Pin compatible with Arduino shields although drivers are required for
some shields.
Vinculo Vinculum II FTDI USB development board for the FTDI Vinculum II microcontroller.
FEZ Domino, FEZ
Panda, and FEZ
Panda II
ARM 72MHz 32-bit ARM (GHI Electronics USBizi chips) micro-controller boards with
support for the .NET Micro Framework. Pin compatible with Arduino shields,
although drivers are required for some shields.
TheUno Freescale
Freescale 8-bit S08DZ60 based Arduino Shield Compatible development board.
Programmable in C or assembly language using the free CodeWarrior development
environment from Freescale, based on Eclipse. Integrated open-source debugging
cable for fast prototyping.
List of Arduino compatibles
BigBrother Freescale
Freescale 32-bit Coldfire MCF51AC256 based Arduino Shield Compatible
development board. Programmable in C or assembly language using the free
CodeWarrior development environment from Freescale, based on Eclipse and in
C++ with CodeSourcery. Integrated open-source debugging cable for fast
prototyping. The first Arduino Shield Compatible board with two Arduino slots to
add more and more shields.
BigBrother-USB Freescale
Freescale 32-bit Coldfire MCF51JM128 based Arduino Shield Compatible
development board. Programmable in C or assembly language using the free
CodeWarrior development environment from Freescale, based on Eclipse and in
C++ with CodeSourcery. Integrated open-source debugging cable for fast
prototyping. The first Arduino Shield Compatible board with two Arduino slots to
add more and more shields.
Firebird32 Coldfire Freescale 32-bit Coldfire MCF51JM128 based Arduino Shield Compatible
development board. Programmable in StickOS BASIC, and C or assembly
language using Flexisframework or CodeWarrior with a step-by-step debugger.
The Firebird32 is also available in a special model based on the 8-bit
PIC or Parallax
Parallax Arduino Shield compatible BASIC Stamp 2 board, interfaces with most standard
Arduino shields. The BS comes with a free IDE.
SunDuinoPIC PIC18F2550 or
Microchip PIC Arduino hardware compatible board. Based PINGUINO Project.
USB HID Bootloader.
PIC Breeze boards are prototyping platforms for 28-pin PIC microcontrollers. They
come with a PIC18F25K22 (USB-UART interface) or PIC18F25J50 (direct USB
interface), however almost any 28-pin PIC can be used with the platform.
Thin Layer Embedded
Goldilocks has three Arduino UNO Shield compatible sockets and a 'helix_4'
FPGA Module with Altera Cyclone IV FPGA, DDR2 DRAM, fast SRAM, serial
Flash, a MEMs oscillator, power supplies and an Atmel ATSHA204
Authentication IC/EEPROM. The 'helix_4' module is notable for castellated edge
connectors; it's designed to be 'soldered-down' to a subsequent PCB development.
List of Arduino compatibles
Thin Layer Embedded
Breadstick has one Arduino UNO Shield compatible socket, 43 GPIO to pin HDRs
for breadboarding, and a lower power 'helix_4' FPGA Module with Altera Cyclone
IV FPGA, fast SRAM, serial Flash, a MEMs oscillator, power supplies and an
Atmel ATSHA204 Authentication IC/EEPROM. The 'helix_4' module is notable
for castellated edge connectors; it's designed to be 'soldered-down' to a subsequent
PCB development.
[1] arduino.cc (http:/ / arduino. cc/ en/ Main/ ArduinoBoardPro)
[2] http:/ / digistump.com/ products/ 1
[3] http:/ / www. bhashatech.com/ boards/ 128-freeduino-nano. html
[4] lowpowerlab.com (http:/ / lowpowerlab.com/ moteino), All about Moteino
[5] lowpowerlab.com (http:/ / www.lowpowerlab.com/ )
[6] (https:/ / github. com/ LowPowerLab/ DualOptiboot) DualOptiboot
[7] parallax.com (http:/ / www.parallax. com/ StoreSearchResults/ tabid/ 768/ txtSearch/ stampduino/ List/ 0/ SortField/ 4/ ProductID/ 842/
[8] Breeze Boards (http:/ / www.dizzy. co.za/ store. asp?category=89) Dizzy Enterprises website
[9] Arduino clone with mikroBUS socket (http:/ / www.mikroe. com/ news/ view/ 530/ arduino-clone-with-mikrobus-socket/ ) mikroElektronika
news article
[10] Goldilocks Dev Board (http:/ / www.thin-layer-embedded. com/ Module+ -+ helix_4#ms_dev) Thin Layer website
[11] http:/ / www.thin-layer-embedded. com
[12] Goldilocks Dev Board (http:/ / www.thin-layer-embedded. com/ Module+ -+ helix_4#breadstick) Thin Layer website
Further reading
Library resources
About List of Arduino boards and compatible systems
Resources in your library (http:/ / tools. wmflabs. org/ ftl/ cgi-bin/ ftl?st=& su=Arduino+ (Microcontroller))
Resources in other libraries (http:/ / tools. wmflabs. org/ ftl/ cgi-bin/ ftl?st=& su=Arduino+ (Microcontroller)& library=0CHOOSE0)
Evans, Martin; Noble, Joshua; Hochenbaum, Jordan (August 28, 2012). Arduino in Action (1st ed.). Manning.
p.300. ISBN978-1617290244.
McComb, Gordon (June 5, 2012). Arduino Robot Bonanza (http:/ / www. mcgrawhill. ca/ professional/ products/
9780071782777/ arduino+ robot+ bonanza/ ) (1st ed.). McGraw-Hill. p.40. ISBN978-0-07-178277-7.
Olsson, Tony (May 30, 2012). Arduino Wearables (http:/ / www. apress. com/ 9781430243595) (1st ed.). Apress.
p.400. ISBN978-1-4302-4359-5.
Anderson, Rick; Cervo, Dan (May 16, 2012). Pro Arduino (http:/ / www. apress. com/ 9781430239390) (1st ed.).
Apress. p.350. ISBN978-1-4302-3939-0.
Wilcher, Don (April 30, 2012). Learn Electronics with Arduino (http:/ / www. apress. com/ 9781430242666) (1st
ed.). Apress. p.350. ISBN978-1-4302-4266-6.
List of Arduino compatibles
Melgar, Enrique Ramos; Diez, Ciriaco Castro Diez (March 26, 2012). Arduino and Kinect Projects: Design,
Build, Blow Their Minds (http:/ / www. apress. com/ 9781430241676) (1st ed.). Apress. p.350.
Bhmer, Mario (March 26, 2012). Beginning Android ADK with Arduino (http:/ / www. apress. com/
9781430241973) (1st ed.). Apress. p.350. ISBN978-1-4302-4197-3.
Jepson, Brian; Igoe, Tom (March 22, 2012). Getting Started with NFC: Contactless Communication with
Android, Arduino, and Processing (http:/ / oreilly. com/ catalog/ 9781449308520/ ) (1st ed.). O'Reilly
Media/Make. p.30. ISBN978-1-4493-0852-0.
Doukas, Charalampos (March 14, 2012). Arduino, Sensors, and the Cloud (http:/ / www. apress. com/
9781430241256) (1st ed.). Apress. p.350. ISBN978-1-4302-4125-6.
Riley, Mike (March 7, 2012). Programming Your Home: Automate with Arduino, Android, and Your Computer
(http:/ / pragprog. com/ book/ mrhome/ programming-your-home) (1st ed.). Pragmatic Bookshelf. p.200.
Igoe, Tom (February 22, 2012). Getting Started with RFID: Identify Objects in the Physical World with Arduino
(http:/ / oreilly. com/ catalog/ 9781449324186) (1st ed.). O'Reilly Media. p.40. ISBN978-1-4493-2418-6.
Borenstein, Greg (February 3, 2012). Making Things See: 3D vision with Kinect, Processing, Arduino, and
MakerBot (http:/ / oreilly. com/ catalog/ 9781449307073/ ) (1st ed.). O'Reilly Media. p.440.
Noble, Joshua (January 30, 2012). Programming Interactivity (http:/ / oreilly. com/ catalog/ 9781449311445/ )
(2nd ed.). O'Reilly Media. p.726. ISBN978-1-4493-1144-5.
Margolis, Michael (December 30, 2011). Arduino Cookbook (http:/ / oreilly. com/ catalog/ 9781449313876) (2nd
ed.). O'Reilly Media. p.724. ISBN978-1-4493-1387-6.
Premeaux, Emery; Evans, Brian (December 7, 2011). Arduino Projects to Save the World (http:/ / www. apress.
com/ 9781430236238) (1st ed.). Apress. p.256. ISBN978-1-4302-3623-8.
Wheat, Dale (November 16, 2011). Arduino Internals (http:/ / www. apress. com/ 9781430238829) (1st ed.).
Apress. p.392. ISBN978-1-4302-3882-9.
Monk, Simon (November 15, 2011). Arduino + Android Projects for the Evil Genius: Control Arduino with Your
Smartphone or Tablet (http:/ / www. arduinoevilgenius. com) (1st ed.). McGraw-Hill. p.224.
Timmis, Harold (November 9, 2011). Practical Arduino Engineering (http:/ / www. apress. com/
9781430238850) (1st ed.). Apress. p.328. ISBN978-1-4302-3885-0.
Monk, Simon (November 8, 2011). Programming Arduino: Getting Started With Sketches (http:/ / www.
arduinobook. com) (1st ed.). McGraw-Hill. p.176. ISBN978-0-07-178422-1.
Evans, Brian (October 17, 2011). Beginning Arduino Programming (http:/ / www. apress. com/ 9781430237778)
(1st ed.). Apress. p.272. ISBN978-1-4302-3777-8.
Igoe, Tom (September 26, 2011). Making Things Talk: Using Sensors, Networks, and Arduino to see, hear, and
feel your world (http:/ / shop. oreilly. com/ product/ 0636920010920. do) (2nd ed.). O'Reilly Media/Make. p.496.
Allan, Alasdair (September 22, 2011). iOS Sensor Apps with Arduino: Wiring the iPhone and iPad into the
Internet of Things (http:/ / oreilly. com/ catalog/ 9781449308483) (1st ed.). O'Reilly Media. p.126.
Banzi, Massimo (September 20, 2011). Getting Started with Arduino (http:/ / shop. oreilly. com/ product/
0636920021414. do) (2nd ed.). O'Reilly Media/Make. p.128. ISBN978-1-4493-0987-9.
Smith, Alan G (August 19, 2011). Introduction to Arduino: A piece of cake (http:/ / www. introtoarduino. com/
downloads/ IntroArduinoBook. pdf) (1st ed.). CreateSpace. p.170. ISBN978-1-4636-9834-8.
Warren, John-David; Adams, Josh; Molle, Harald (July 18, 2011). Arduino Robotics (http:/ / www. apress. com/
book/ view/ 9781430231837) (1st ed.). Apress. p.450. ISBN978-1-4302-3183-7.
List of Arduino compatibles
Karvinen, Tero; Karvinen, Kimmo (April 6, 2011). Make: Arduino Bots and Gadgets: Six Embedded Projects
with Open Source Hardware and Software (http:/ / shop. oreilly. com/ product/ 0636920010371. do) (1st ed.).
O'Reilly Media/Make. p.296. ISBN978-1-4493-8971-0.
Margolis, Michael (March 15, 2011). Arduino Cookbook (http:/ / oreilly. com/ catalog/ 9780596802479) (1st ed.).
O'Reilly Media. p.660. ISBN978-0-596-80247-9.
Schmidt, Maik (March 10, 2011). Arduino: A Quick Start Guide (http:/ / pragprog. com/ titles/ msard/ arduino)
(1st ed.). The Pragmatic Bookshelf. p.296. ISBN978-1-934356-66-1.
Faludi, Robert (January 4, 2011). Building Wireless Sensor Networks: with ZigBee, XBee, Arduino, and
Processing (http:/ / www. isbnlib. com/ isbn/ 0596807732/
Building-Wireless-Sensor-Networks-With-ZigBee-XBee-Arduino-and-Processing) (1st ed.). O'Reilly Media.
p.320. ISBN978-0-596-80774-0.
McRoberts, Michael (December 20, 2010). Beginning Arduino (http:/ / www. apress. com/ book/ view/
9781430232407) (1st ed.). Apress. p.350. ISBN978-1-4302-3240-7.
Monk, Simon (August 23, 2010). 30 Arduino Projects for the Evil Genius (http:/ / www. arduinoevilgenius.com)
(1st ed.). McGraw-Hill. p.208. ISBN978-0-07-174133-0.
F. Barrett, Steven; Thornton, Mitchell (April 30, 2010). Arduino Microcontroller Processing for Everyone! (http:/
/ isbnlib. com/ isbn/ 1608454371/
Arduino-Microcontroller-Processing-for-Everyone-Synthesis-Lectures-on-Digital-Ci) (1st ed.). Morgan and
Claypool Publishers. p.344. ISBN978-1-60845-437-2.
Pardue, Joe (January 15, 2010). An Arduino Workshop (http:/ / smileymicros. com/ index.
php?module=pagemaster& PAGE_user_op=view_page& PAGE_id=82) (1st ed.). Smiley Micros. p.214.
Oxer, Jonathan; Blemings, Hugh (December 28, 2009). Practical Arduino: Cool Projects for Open Source
Hardware (http:/ / www. apress. com/ book/ view/ 9781430224778) (1st ed.). Apress. p.450.
Noble, Joshua (July 15, 2009). Programming Interactivity: A Designer's Guide to Processing, Arduino, and
openFrameworks (http:/ / oreilly. com/ catalog/ 9780596154141/ ) (1st ed.). O'Reilly Media. p.736.
External links
Media related to Arduino compatibles at Wikimedia Commons
Wiring (development platform)
Wiring (development platform)
Developer(s) Hernando Barragn, Brett Hagman, and Alexander Brevig
Stable release 1.0 (0100) / 18October 2011
Operating system Cross-platform
Type Software framework, integrated development environment
License LGPL or GPL license
Wiring is an open source electronics prototyping platform composed of a programming language, an integrated
development environment (IDE), and a single-board microcontroller. It was developed starting in 2003 by Hernando
Barragn started the project at the Interaction Design Institute Ivrea. The project is currently developed at the School
of Architecture and Design at the Universidad de Los Andes in Bogot, Colombia.
Wiring builds on Processing, an open project initiated by Casey Reas and Benjamin Fry, both formerly of the
Aesthetics and Computation Group at the MIT Media Lab.
The documentation has been created thoughtfully, with designers and artists in mind. There is a community where
experts, intermediate developers and beginners from around the world share ideas, knowledge and their collective
experience. Wiring allows writing software to control devices attached to the electronics board to create all kinds of
interactive objects, spaces or physical experiences feeling and responding in the physical world. The idea is to write
a few lines of code, connect a few electronic components to the Wiring hardware and observe how a light turns on
when person approaches it, write a few more lines, add another sensor, and see how this light changes when the
illumination level in a room decreases. This process is called sketching with hardware; explore lots of ideas very
quickly, select the more interesting ones, refine and produce prototypes in an iterative process.
The Wiring IDE is a cross-platform application written in Java which is derived from the IDE made for the
Processing programming language. It is designed to introduce programming and sketching with electronics to artists
and designers. It includes a code editor with features such as syntax highlighting, brace matching, and automatic
indentation capable of compiling and uploading programs to the board with a single click.
The Wiring IDE comes with a C/C++ library called "Wiring", which makes common input/output operations much
easier. Wiring programs are written in C/C++, although users only need to define two functions to make a runnable
setup() a function run once at the start of a program which can be used to define initial environment settings
loop() a function called repeatedly until the board is powered off
A typical first program for a microcontroller is to simply blink an LED (light-emitting diode) on and off. In the
Wiring environment, the user might write a program like this:
int ledPin = WLED; // a name for the on-board LED
void setup () {
pinMode(ledPin, OUTPUT); // set pin 48 for digital output
Wiring (development platform)
void loop () {
digitalWrite(ledPin, HIGH); // turn on the LED
delay (1000); // wait one second (1000 milliseconds)
digitalWrite(ledPin, LOW); // turn off the LED
delay (1000); // wait one second
When the user clicks the "Upload to Wiring hardware" button in the IDE, a copy of the code is written to a
temporary file with an extra include header at the top and a very simple main() function at the bottom, to make it a
valid C++ program.
The Wiring IDE uses the GNU toolchain and AVR Libc to compile programs, and uses avrdude to upload programs
to the board.
Open hardware and open source
The Wiring hardware reference designs are distributed under a Creative Commons Attribution Share-Alike 2.5
license and are available on the Wiring Web site. Layout and production files for the Wiring hardware are also
available. The source code for the IDE and the hardware library are available and released under the GPLv2
Related projects
Wiring was based on the original work done on Processing project in MIT.
Arduino and Fritzing
Wiring and Processing have spawned another project, Arduino, which uses the Processing IDE, with a simplified
version of the C++ language, as a way to teach artists and designers how to program microcontrollers. There are now
two separate hardware projects, Wiring and Arduino, using the Wiring environment and language.
Fritzing is another software environment within this family, which supports designers and artists to document their
interactive prototypes and to take the step from physical prototyping to actual product.
Reas, Casey; Fry, Ben; Maeda, John (September 30, 2007), Processing: A Programming Handbook for Visual
Designers and Artists
(1st ed.), The MIT Press, p.736, ISBN0-262-18262-9
Igoe, Tom (September 28, 2007). Making Things Talk: Practical Methods for Connecting Physical Objects
(1st ed.). O'Reilly Media. p.432. ISBN0-596-51051-9.
Noble, Joshua (July 15, 2009). Programming Interactivity: A Designer's Guide to Processing, Arduino, and
(1st ed.). O'Reilly Media. p.768. ISBN0-596-15414-3.
[1] http:/ / wiring.org. co
[2] http:/ / mitpress. mit. edu/ catalog/ item/ default.asp?ttype=2& tid=11251
[3] http:/ / oreilly.com/ catalog/ 9780596510510/
[4] http:/ / oreilly.com/ catalog/ 9780596800581/
Wiring (development platform)
External links
Official website (http:/ / wiring. org. co)
Processing.org (http:/ / www. processing. org/ )
Arduino (http:/ / www. arduino. cc/ )
Fritzing (http:/ / www. fritzing. org/ )
Processing (programming language)
Paradigm(s) object-oriented
Appeared in 2001
Stable release 2.1 (October27, 2013)
Typing discipline strong
Influenced by Design By Numbers, Java, OpenGL, PostScript, C
OS Cross-platform
License GPL, LGPL
Usual filename extensions .pde
Processing is an open source programming language and integrated development environment (IDE) built for the
electronic arts, new media art, and visual design communities with the purpose of teaching the fundamentals of
computer programming in a visual context, and to serve as the foundation for electronic sketchbooks. The project
was initiated in 2001 by Casey Reas and Benjamin Fry, both formerly of the Aesthetics and Computation Group at
the MIT Media Lab. One of the stated aims of Processing is to act as a tool to get non-programmers started with
programming, through the instant gratification of visual feedback. The language builds on the Java language, but
uses a simplified syntax and graphics programming model.
Processing (programming language)
A screenshot of the Processing IDE
Stable release 2.0.2 / August14, 2013
Written in Java, GLSL, JavaScript
Processing includes a sketchbook, a minimal alternative to an integrated development environment (IDE) for
organizing projects.
Every Processing sketch is actually a subclass of the PApplet
Java class which implements most of the
Processing language's features.
When programming in Processing, all additional classes defined will be treated as inner classes when the code is
translated into pure Java before compiling. This means that the use of static variables and methods in classes is
prohibited unless you explicitly tell Processing that you want to code in pure Java mode.
Processing also allows for users to create their own classes within the PApplet sketch. This allows for complex data
types that can include any number of arguments and avoids the limitations of solely using standard data types such
as: int (integer), char (character), float (real number), and color (RGB, ARGB, hex).
Hello World
The Processing equivalent of a Hello World program is simply to draw a line:
line(15, 25, 70, 90);
Also, the following code is a better example of the look and feel of the language.
//Hello mouse.
void setup() {
size(400, 400);
background(192, 64, 0);
void draw() {
line(150, 25, mouseX, mouseY);
Processing (programming language)
United States presidential election map
Output of the following example
The next example shows a map of the results of the 2008 USA
presidential election. Blue denotes states won by Barack Obama, and
red denotes those won by John McCain. (Note: this map does not show
the Nebraska district in which Obama won an elector.)
PShape usa;
PShape state;
String [] Obama = { "HI", "RI", "CT", "MA", "ME", "NH", "VT", "NY",
"FL", "NC", "OH", "IN", "IA", "CO", "NV", "PA", "DE", "MD",
"WA", "CA", "OR", "IL", "MN", "WI", "DC", "NM", "VA" };
String [] McCain = { "AK", "GA", "AL", "TN", "WV", "KY", "SC", "WY",
"ID", "TX", "AZ", "UT", "ND", "SD", "NE", "MS", "MO", "AR",
"KS", "LA" };
void setup() {
size(950, 600);
// The file Blank_US_Map.svg can be found at Wikimedia Commons
usa =
smooth(); // Improves the drawing quality of the SVG
void draw() {
// Draw the full map
shape(usa, 0, 0);
// Blue denotes states won by Obama
statesColoring(Obama , color(0, 0, 255));
// Red denotes states won by McCain
statesColoring(McCain, color(255, 0, 0));
// Save the map as image
saveFrame("map output.png");
Processing (programming language)
void statesColoring(String[] states, int c){
for (int i = 0; i < states.length; ++i) {
PShape state = usa.getChild(states[i]);
// Disable the colors found in the SVG file
// Set our own coloring
// Draw a single state
shape(state, 0, 0);
Related projects
Design By Numbers
Processing was based on the original work done on Design By Numbers project in MIT. It shares many of the same
ideas and is a direct child of that experiment.
Wiring, Arduino, and Fritzing
Processing has spawned another project, Wiring, which uses the Processing IDE with a simplified version of the C++
language as a way to teach artists how to program microcontrollers. There are now two separate hardware projects,
Wiring and Arduino, using the Wiring environment and language. Fritzing is another software environment of the
same sort, which helps designers and artists to document their interactive prototypes and to take the step from
physical prototyping to actual product.
Mobile Processing
Another spin-off project, now defunct, is Mobile Processing
by Francis Li, that allowed software written using the
Processing language and environment to run on Java powered mobile devices. Today some of the same functionality
is provided by Processing itself.
In 2008, John Resig ported Processing to JavaScript using the Canvas element for rendering,
allowing Processing
to be used in modern web browsers without the need for a Java plugin. Since then, the open source community
including students at Seneca College have taken over the project.
iProcessing was built to help people develop native iPhone applications using the Processing language. It is an
integration of the Processing.js library and a Javascript application framework for iPhone.
Spde (standing for Scala Processing Development Environment) replaces Processing's reduced Java syntax and
custom preprocessor with the off-the-shelf Scala programming language which also runs on the Java platform and
enforces some of the same restrictions such as disallowing static methods, while also allowing more concise code,
and supporting functional programming.
Processing (programming language)
Quil (formerly named clj-processing) is a wrapper for Processing in the Clojure language, a Lisp that runs on the
Java platform.
In 2005 Reas and Fry won the prestigious Golden Nica award from Ars Electronica in its Net Vision category for
their work on Processing.
Ben Fry won the 2011 National Design Award
given by the Smithsonian Cooper-Hewitt National Design
Museum in the category of Interaction Design. The award statement says:
"Drawing on a background in graphic design and computer science, Ben Fry pursues a long-held fascination with
visualizing data. As Principal of Fathom Information Design in Boston, Fry develops software, printed works,
installations, and books that depict and explain topics from the human genome to baseball salaries to the evolution of
text documents. With Casey Reas, he founded the Processing Project, an open-source programming environment for
teaching computational design and sketching interactive-media software. It provides artists and designers with
accessible means of working with code while encouraging engineers and computer scientists to think about design
Processing's core libraries, the code included in exported applications and applets, is licensed under the GNU Lesser
General Public License, allowing users to release their original code with a choice of license.
The IDE is licensed under the GNU General Public License.
Originally, Processing had the URL at proce55ing.net, because the processing domain was taken. Eventually,
however, Reas and Fry acquired the domain. Although the name had a combination of letters and numbers, it was
still pronounced processing. They do not prefer the environment being referred to as Proce55ing. But, despite the
name change, Processing still uses the term p5 sometimes as a shortened name. However, they specifically use p5
and not p55. Unfortunately the choice of such a generic name as processing results in many irrelevant results when
searching for this programming language on the internet.
[1] http:/ / www. processing. org
[2] http:/ / processing.googlecode. com/ svn/ trunk/ processing/ build/ javadoc/ core/ processing/ core/ PApplet. html
[3] http:/ / mobile.processing.org/
[4] John Resig - Processing.js (http:/ / ejohn. org/ blog/ processingjs/ )
[5] Spde: Spde (http:/ / technically.us/ spde/ About). Technically.us. Retrieved on 2013-08-20.
[6] Coderspiel / Runaway processing (http:/ / technically. us/ code/ x/ runaway-processing/ ). Technically.us. Retrieved on 2013-08-20.
[7] Coderspiel / Flocking with Spde (http:/ / technically.us/ code/ x/ flocking-with-spde/ ). Technically.us. Retrieved on 2013-08-20.
[8] quil/quil GitHub (http:/ / github.com/ quil/ quil). Github.com. Retrieved on 2013-08-20.
[9] http:/ / cooperhewitt.org/ nda/ awards/ interaction-design
Processing (programming language)
Bohnacker, Hartmut; Gross, Benedikt; Laub, Julia; Lazzeroni, Claudius (August 22, 2012), Generative Design:
Visualize, Program, and Create with Processing (1st ed.), Princeton Architectural Press, p.472,
Glassner, Andrew (August 9, 2010), Processing for Visual Artists: How to Create Expressive Images and
Interactive Art (http:/ / www. crcpress. com/ ecommerce_product/ product_detail. jsf?isbn=9781568817163) (1st
ed.), A K Peters/CRC Press, p.955, ISBN1-56881-716-9
Reas, Casey; Fry, Ben (June 17, 2010), Getting Started with Processing (1st ed.), Make, p.208,
Noble, Joshua (July 21, 2009), Programming Interactivity: A Designer's Guide to Processing, Arduino, and
Openframeworks (http:/ / oreilly. com/ catalog/ 9780596154141/ ) (1st ed.), O'Reilly Media, p.736,
Terzidis, Kostas (May 11, 2009), Algorithms for Visual Design Using the Processing Language (http:/ / www.
wiley. com/ WileyCDA/ WileyTitle/ productCd-0470375485. html) (1st ed.), Wiley, p.384, ISBN0-470-37548-5
Reas, Casey; Fry, Ben; Maeda, John (September 30, 2007), Processing: A Programming Handbook for Visual
Designers and Artists (http:/ / mitpress. mit. edu/ catalog/ item/ default. asp?ttype=2& tid=11251) (1st ed.), The
MIT Press, p.736, ISBN0-262-18262-9
Fry, Ben (January 11, 2008), Visualizing Data (http:/ / oreilly. com/ catalog/ 9780596514556/ ) (1st ed.), O'Reilly
Media, p.382, ISBN0-596-51455-7
Greenberg, Ira (May 28, 2007), Processing: Creative Coding and Computational Art (Foundation) (http:/ /
friendsofed. com/ book. html?isbn=159059617X) (1st ed.), friends of ED, p.840, ISBN1-59059-617-X
Shiffman, Daniel (August 19, 2008), Learning Processing: A Beginner's Guide to Programming Images,
Animation, and Interaction (http:/ / www. learningprocessing. com/ ) (1st ed.), Morgan Kaufmann, p.450,
Faludi, Robert (January 4, 2011), Building Wireless Sensor Networks: with ZigBee, XBee, Arduino, and
Processing (http:/ / faludi. com/ bwsn) (1st ed.), O'Reilly Media, p.320, ISBN978-0-596-80774-0
Vantomme, Jan (September 20, 2012), Processing 2, Creative Programming Cookbook (http:/ / www. packtpub.
com/ processing-2-creative-programming-cookbook/ book) (1st ed.), Packt Publishing, p.291,
Pearson, Matt (June 1, 2011), Generative Art, A practical guide using Processing (http:/ / zenbullets. com/ book.
php) (1st ed.), Manning, p.240, ISBN9781935182627
Jan, Vantomme (September 20, 2012), Processing 2: Creative Programming Cookbook (http:/ / www. packtpub.
com/ processing-2-creative-programming-cookbook/ book) (1st ed.), Packt Publishing, p.306,
Sauter, Daniel (May 2, 2013), Rapid Android Development: Build Rich, Sensor-Based Applications with
Processing (http:/ / pragprog. com/ book/ dsproc/ rapid-android-development) (1st ed.), Pragmatic Bookshelf,
p.300, ISBN978-1937785062
Gradwohl, Nikolaus (May 20, 2013), Processing 2: Creative Coding Hotshot (http:/ / www. packtpub. com/
processing-2-creative-coding-hotshot/ book) (1st ed.), Packt Publishing, p.266, ISBN978-1782166726
Processing (programming language)
External links
Official website (http:/ / www. processing. org)
Processing.js official website (http:/ / www. processingjs. org/ )
Official wiki (http:/ / wiki. processing. org/ w/ Main_Page)
Official forum (http:/ / forum. processing. org/ )
OpenProcessing - sketches library (http:/ / www. openprocessing. org/ )
Processing.js blog (http:/ / ejohn. org/ blog/ processingjs/ )
Processing.js Google group (http:/ / groups. google. com/ group/ processingjs)
Working with Processing and Arduino (http:/ / luckylarry. co. uk/ category/ programming/ processing/ )
Website (German) to the book with nice source-codes and examples (http:/ / www. generative-gestaltung. de)
Ruby-Processing, which is a ruby wrapper around the Processing code art framework, built using JRuby (https:/ /
github. com/ jashkenas/ ruby-processing)
Article Sources and Contributors
Article Sources and Contributors
Arduino Source: http://en.wikipedia.org/w/index.php?oldid=583675016 Contributors: 392236a, 84user, A Pirard, ATH500, Abdull, Abishai Singh, ActivExpression, Adamfeuer, Aervanath,
Ajfweb, Alainr345, Ales9000, Ali asin, Allen Moore, Alphathon, Amalas, Amatulic, Andy Dingley, Angmall, Anilashanbhag, ArnoldReinhold, Arny, Arthur Rubin, Ashishbuntybhaiya, Attilios,
Awickert, AxelBoldt, BKJanzen, Barefoottech, BenFrantzDale, Bentogoa, Bernd.Brincken, Bevo74, Blanchardb, Bobo192, Borg4223, Bovineone, Brad Dyer, Braincricket, Bricoman55,
Brunonar, Bsx, CUSENZA Mario, Cadsuane Melaidhrin, Caltrop, Calwiki, Carafriez, CasualVisitor, Cbenson1, Ceaser, Chaosdruid, CharlesC, Chendy, Chuckwolber, ClarkMills, Clay Digger,
Cmkpl, ColorfulNumbers, Compfreak7, CosineKitty, Courcelles, Craigbic, Crazyburns, Csigabi, Cst17, Cyb3rn0id, DMellis, Dairhead, Darkwind, David Oliver, Dead Horsey, Delirium,
Discospinster, DocWatson42, Donio, Download, Dro Kulix, Ds13, Dspradau, Duchamp, DustyDingo, E-Soter, Edsfocci, Elkman, ErikvanB, Exprice, Fabrice Florin, Faisal.akeel, Fargasch,
Fiskbil, FlyFire, Frap, Frze, Gandrewstone, Gbarberi, Gbulmeruk, George Church, Ghstwlf, Giraffedata, Glenn, Gonzalo M. Garcia, Gracehoper, GreenSpigot, Grhabyt, Guy Macon, Gwern,
H0dges, H3llbringer, Halosix, Harviecz, Howetimothy, Hscharler, Htbwmedia, Hu12, Hydrargyrum, ICSeater, Ian Spackman, Idyllic press, Imheck, Imroy, Intgr, InverseHypercube,
IronGargoyle, JLaTondre, JaadesA, JackStonePGD, Jamelan, JamesBWatson, Jantangring, Jarble, Jatkins, Jdabney, JennyRad, JimVC3, Jinlye, Jjolla88, Jluciani, Jncraton, Joebigwheel,
Johanroed, John Garvin, JohnBoxall, JonHarder, JonOxer, Jonathan Williams, Jorge Stolfi, Julian dasilva, Khazar2, Khommel, Kingboyk, Kirstine Dupont, Kku, Klaus Leiss, Knobunc, Kookish,
Kozuch, Kragen, Kristianpaul, Kronick, Laure f o, Ldsrc2008, Lemio, Lethalmonk, Lexein, LilHelpa, Linuxrules1337, Lmatt, LordStDennis, Lorem Ip, Luckylarrycouk, Luli17, MWikiOrg,
MZMcBride, Machee, MaharajaMD, Mahjongg, MakerShed, Marasmusine, Mardus, MarkAStephenson, Mazurov, McGeddon, Mfoulks3200, Michael9422, Micru, Migaber, Mikebar,
Mindmatrix, Minime72706, Misiu mp, Misto, MoreNet, Mort42, Mortense, Moumouza, Mowcius, MrOllie, Mulad, Mwtoews, Nasukaren, Nave.notnilc, Neoforma, Nexus501, Nick Wilson,
NickGarvey, NobbiP, Nv8200p, Obankston, Olonic, Onorai, Oskay, Pabhilash, PabloCastellano, Palosirkka, Paradoxiality, Patrick Gill, PatrickCarbone, Pdecalculus, Peapodamus, Pemboid,
Pfagerburg, Pfhyper, Phry, Pol098, Potax, Prestja, PutzfetzenORG, R. S. Shaw, RA0808, Radical Mallard, Raeky, Rajsite, Randomskk, RaphaelQS, Razvaniycdi, Remmelt, RickO5, Riktw,
Rjwilmsi, Rob Prikanowski, Robertelder, Roguebhagman, Roweboat14, Royan, Rstuvw, Rusfuture, Ruud Koot, Rvumbaca, SDC, Salamurai, Salvor, Samyulg, Sav vas, Sbassi, Sbmeirow, Scgtrp,
ScotXW, Scott Martin, Scruss, Se Ra Bu Tan, Seb az86556, Sgbirch, Shields Arduino, Shiki2, Shloimeborukh, SimenH, SimonPStevens, Simonmonk2, Snakomaniac, Snaxe920, Softy, Soler97,
Sprague, Srcvale, Sreeram shankar, Stepho-wrs, Steven Walling, Sukkin, Surturz, TLeek, Taxman, Tbhotch, Techformeplease, Tedder, Tehuglyscientist, Tergenev, TerryKing, Theoduino,
Theskuter37, Thomas-pluralvonglas, Thorwald, Thumperward, Tikitpok, Tintin192, TjeerdVerhagen, Tkbwik, Toastcoast, TobiasAD, Toggio, Treekids, Trevj, Tronixstuff, Troy.hester, Tuxskar,
Ubarro, Udawatabhimanyu4, Udoklein, Userper, VQuakr, Val42, Vancircuit, Vbscript2, Velella, Venix, Vinnycordeiro, Virtualerian, Viskr, W Nowicki, WAYNELYW, Waveking,
WikiEditingResearcher, Wimh, Wknight94, Wrachelson, Xan2, Yadoo86, Yannick56, Yaris678, Yintan, Yngvarr, Youdonotknow, Yworo, Zlogic, Zodon, carusdaidalos, ,
, 553 anonymous edits
Single-board microcontroller Source: http://en.wikipedia.org/w/index.php?oldid=555944259 Contributors: Alanl, Andy Dingley, Danim, Download, Fsmoura, Gizzakk, Guy Macon, J04n, Jeh,
Kuyabribri, Lyktorna, Mandylau, Mika1h, Mortense, Nepenthes, Onorai, Pfagerburg, Praveen khm, Raesak, Sbmeirow, Stidem, TerryKing, Wimh, Wtshymanski, 24 anonymous edits
Atmel AVR Source: http://en.wikipedia.org/w/index.php?oldid=579242426 Contributors: (aeropagitica), 16@r, Abdull, Akilaa, Akkazemi, Alan Liefting, Alexf, Alf, Alphathon, Alvin-cs,
Amanparkash, Andy Dingley, AndyHe829, Ani8051, Arsenikk, Ashoksharmaz87, AshtonBenson, Atmelfan, Bb3cxv, Bender235, Bluelip, Bonnie13J, Bozoid, Brooknet, Brunonar, C. A. Russell,
Can't sleep, clown will eat me, Cbogart2, Cburnett, Chappell, Chbarts, Choppingmall, Chowbok, Chris the speller, Chungyan5, Ckgrier2, Crotalus horridus, DanielHolth, Danim, DavidCary,
Dead Horsey, Dennis Brown, Derek R Bullamore, DexDor, Dkinzer, Dorutc, Doruu, Doruuu, Dugosz, Egil, Electron9, Epbr123, EthanL, Evil saltine, Ex nihil, Ffierling, Firstrock, FlyingToaster,
Foobaz, Frap, FtPeter, Gablix, Gagarine, Gaius Cornelius, Gauravsangwan, GcSwRhIc, Glenn, Goffrie, Goosnarrggh, GrahamDavies, Groink, Guy Macon, Hmms, Homo stannous, Hossein4737,
Hydrargyrum, Identime, Imroy, Iswantoumy, JLD, Jauricchio, Jbattersby, Jcswright2, Jeff Wheeler, Jeroen74, Jevinsweval, Jfmantis, Jidan, Jim1138, Jonathanfu, Julien, Kelly Martin,
Kevin.kirkup, Kingpin13, Kirchhoffvl, Kms, KnightRider, Krikkit1, Kshdeo, Ksvitale, Kushagraalankar, Letter4vishal, Ljudina, Lmatt, Lotje, Lunakid, Mahjongg, Mahmoodheshmati, Martarius,
Masgatotkaca, Mauiflyer, Maury Markowitz, Maxim Razin, McNeight, Mcleanj1, Mdulcey, Mellery, Metalliqaz, Mihaigalos, Mitch feaster, Mo ainm, Mogism, Mojo-chan, Morcheeba,
Mortense, Moxfyre, MrOllie, Mrbill, Mrtangent, MultiPoly, Nerd bzh, Night Ravager, NobbiP, Ordoon, Osiixy, Oskay, Ottobonn, PGSONIC, Pengo, Pfagerburg, Phil websurfer@yahoo.com,
PhilKnight, PierreAbbat, PigFlu Oink, Pmod, ProtocolOH, Puffin, Puguhwah, Qwerty9030, R'n'B, RedWolf, Reedy, Rehnn83, Rhobite, Rnsanchez, Robdurbar, Roy tate, Royalguard11, SDiZ,
Sarenne, Sbmeirow, Sbogdanov, Sefid par, Shaddack, Smial, Smishek, Stan Shebs, Steve1608, Stevenyu, Suruena, Susan714, That Guy, From That Show!, ThePianoMan, Thrapper, TimBentley,
Tomitech, Toresbe, Toussaint, Tovven, Toxygen, Transcendent, Trevor MacInnis, USB1000, Unixxx, Van helsing, Versageek, Vesa Linja-aho, Vibhutesh, Vrwlv, Vwollan, Wavelength,
Wernher, WriterHound, Zbaird, 495 anonymous edits
Atmel AVR instruction set Source: http://en.wikipedia.org/w/index.php?oldid=571841646 Contributors: Alvin-cs, ArnoldReinhold, AshtonBenson, Boobarkee, Bovineone, CapitalR,
Chinakow, CrazyTerabyte, Danim, DavidCary, Dkinzer, Doruuu, Frietjes, Gurch, Marudubshinki, MidoriKid, Mortense, Nazli, Pfagerburg, Rl, Rwwww, Suruena, Svofski, Tomasf, Vwollan,
Wernher, Who then was a gentleman?, Wjl2, WriterHound, 17 anonymous edits
Orthogonal instruction set Source: http://en.wikipedia.org/w/index.php?oldid=578036927 Contributors: Anuclanus, Arjun G. Menon, Arnero, Atlant, Barbaraburg45, Blacknova, Blaxthos,
Brianski, CarlosCoppola, ChrisGualtieri, Cybercobra, Davitf, Drichards2, Ds13, Edward, Furrykef, GermanX, Ghiraddje, HenkeB, IanOsgood, Jerome Charles Potts, JonHarder, Kbdank71,
Kindall, Krauss, Lady Tenar, Lightmouse, Ligulem, Macrakis, Metta Bubble, Murray Langton, Neilc, Ospalh, PeterBrooks, Prari, Qwertyus, Rchandra, SDC, SimonP, Spearhead,
Spike-from-NH, Swerdnaneb, TimBentley, Voidxor, Wtshymanski, 36 anonymous edits
Open-source hardware Source: http://en.wikipedia.org/w/index.php?oldid=583354159 Contributors: 122589423KM, AbsolutDan, Acelros, Ajv39, Alan Liefting, AlexanderChemeris,
Alinke2000, AlistairMcMillan, Allstarecho, Altermike, Andrwsc, Andy Dingley, Anthony Appleyard, ArcAngel, Armando, ArnoldReinhold, AtTheAbyss, Atama, Axl, Batboys, BazokaJoe,
Bborg96, Beetstra, Berntie, Biasoli, Bigcheesegs, Biker Biker, Bjonnh, Bluerasberry, Brunonar, C777, Carl.bunderson, CesarB, Changfang, CharlesC, Chendy, Chrissi, CommonsDelinker,
Comte0, Csepartha, CubeSpawn, CyberAran, Cyberied, Dancter, Dave104, David Latapie, DavidCary, Dvansickle, East3YrsWest3Yrs, Electron9, Emijrp, Enviro1, Erpingham, FrancisTyers,
Frap, Fred Bradstadt, Frencheigh, G716, GBYork, Gadfium, Gaius Cornelius, Gakrivas, Galadh, GermanX, Ghettoblaster, Gronky, Guy Macon, Guyjohnston, Gwern, Haakon, Harumphy, Hu12,
HybridBoy, I already forgot, Iamreddave, IjonTichyIjonTichy, Imphil2, Imrehg, Intgr, Jamelan, Jarble, Jcarroll, Jdwolin, Jeremybennett, Jidan, Jlndrr, Jmreinhart, JoeBorn, Jojhutton, JonHarder,
Jona, Jonathanfu, Jorunn, Juliusbaxter, Jwinius, KVDP, Kanzure, KellyCoinGuy, Khalid hassani, Kjkolb, Kl4m-AWB, Klingoncowboy4, Kocio, Kozuch, L3lackEyedAngels, Letdorf,
Lightmouse, Loic.urbain, Luli17, Lunochod, Mac, Magioladitis, Marcus Qwertyus, Marudubshinki, Maxkreusen, Mcintireallen, Micru, Mindmatrix, Miserlou, Mrand, Nczempin, Nerd bzh,
Neustradamus, Nixdorf, Nopetro, Nowa, Nukeless, OHDIY, Oliver Bestwalter, Omegatron, Osat44, Panscient, Phoenix-forgotten, Plaasjaapie, Plasmon1248, Polto, Popolon, Psd, Ramu50,
Raulshc, Rayofdawn24, Raysonho, Regibox, RickHolder, Rob Kam, Robert.Harker, Robvanbasten, Ronz, RossPatterson, Savuporo, Scientus, SebastianPichelhofer, Sfan00 IMG, Shorespirit,
Sikku, SimenH, Simone Cicero, Sjorford, Snaxe920, Snowman76, Sonjaaa, Steelpillow, Stephane.magnenat, SteveSims, Steven Walling, Stockwellnow, Stromcarlson, SunDragon34, Suruena,
Tacvek, Themfromspace, Thiago.correa, Thumperward, Tjteru, Todrobbins, Tony1, Toussaint, Trkiehl, Trusilver, Tucoxn, Ultrajosh, Ultraux2, Uze6666, Vancircuit, Veikk0.ma,
Vincenzo.romano, WAS 4.250, Warrakkk, Wayaguo, Wikkrockiana, Worldpuppet, Xhienne, -1, 280 anonymous edits
List of Arduino compatibles Source: http://en.wikipedia.org/w/index.php?oldid=534638361 Contributors: Aalbino, Ajv39, Alexf, Andy Dingley, Arosa, Bemerit, Blockthor, Brentsinger, Chris
the speller, ChrisGualtieri, ColBatGuano, Daneduplooy, Danim, Dascyllus, Dthomsen8, Estratos, Eumolpo, Felixemman, Geek1337, Gpanos123, Greg75FR, Guy Macon, Happyman7,
Howtronics, Imroy, Jamesmorrison, Jcw, Jojo69003, Josve05a, KylieTastic, Lexein, LilHelpa, LuwieThong, Mblumber, Micru, Mogism, Mortense, Osndok, RHaworth, Rahulmothiya, Sbmeirow,
Sepiaz, Sharya77, Slicmicro, Sodaq, Southwolf, Steven Zhang, TerryKing, ThongEric, Thumperward, Tiisaidipjp, Viskr, Wtshymanski, Youdonotknow, Zzglenm, 70 anonymous edits
Wiring (development platform) Source: http://en.wikipedia.org/w/index.php?oldid=568678231 Contributors: AlexanderBrevig, Andy Dingley, Armbrust, Bearcat, Ben Ben, Brunonar,
Cybercobra, Dcoetzee, EoGuy, Ethridgela, Gbruin, Jerryobject, Micru, Mikebar, Mortense, Roguebhagman, Thumperward, Tzf, Virtualerian, Wikilolo, Woohookitty, 8 anonymous edits
Processing (programming language) Source: http://en.wikipedia.org/w/index.php?oldid=579509623 Contributors: !Silent, Andersonfreitas, Andy Dingley, Beao, Bierons1, Boomur,
CBlair1986, CRGreathouse, Carel.jonkhout, Cecropia, Cfust, CharlesC, Chuckhoffmann, Compfreak7, Cooperh, Crodrigues, Cropoilbrush, Cybercobra, Ddon, Digisage, Duanerbailey,
Dysprosia, EdC, Finlay McWalter, FinnFitzsimons, Franois Robere, Frap, Gracenotes, HMSSolent, Hazem92, HereToHelp, Hu12, Imapiekindaguy, Imroy, InShaneee, Iridescent, Ironwolf,
JWB, Janvantomme, Jeresig, Jerri Kohl, Jerryobject, Joakim Ziegler, John259, Johndci, Johnkershaw, Joosep-Georg, Jschnur, JustinHall, Kaini, KuwarOnline, L Kensington, Lorem Ip, Lthornsb,
Masaruemoto, Metlin, Mikechen, Morphh, Mortense, Mrgates, Multikev, Neko18, Oolong, Pcatanese, Phlingpong, Pol098, Professor Calculus, Rainulf, Rkyymmt, Rstuvw, SCLu, SF007,
SanFranArt, Serj.by, Serprex, Shaomeng, SimShanith, SimenH, SimonP, Sj, Skanaar, T.kalka, ThePCKid, Thumperward, TimmmmCam, Topbanana, Toxmeister, Trevor Wennblom, Tripodics,
Umawera, VX, ViperSnake151, VisualStory, WisCheese, Yaxu, Zarex, 181 anonymous edits
Image Sources, Licenses and Contributors
Image Sources, Licenses and Contributors
File:Arduino Logo.svg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Logo.svg License: Public Domain Contributors: Cathy Richards, Chaojoker, De728631, Jduncanator, 1
anonymous edits
File:Arduino Uno - R3.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Uno_-_R3.jpg License: Creative Commons Attribution 2.0 Contributors: SparkFun Electronics
from Boulder, USA
File:UnoConnections.jpg Source: http://en.wikipedia.org/w/index.php?title=File:UnoConnections.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors: User:1sfoerster
File:Arduino316.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino316.jpg License: Creative Commons Attribution-ShareAlike 3.0 Contributors: Nicholas Zambetti
Image:Arduino_Diecimila_6.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Diecimila_6.jpg License: Creative Commons Attribution 2.0 Contributors: Remko van
Image:Arduino Duemilanove 2009b.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Duemilanove_2009b.jpg License: Public Domain Contributors: H0dges
Image:Arduino UNO unpacked.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_UNO_unpacked.jpg License: Creative Commons Attribution 2.0 Contributors: Nick
Image:Arduino Leonardo.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Leonardo.jpg License: Creative Commons Attribution-Sharealike 2.0 Contributors: Jeremy
Image:Arduino Mega.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Mega.jpg License: Creative Commons Attribution 2.0 Contributors: David Mellis
Image:Arduino Nano.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Nano.jpg License: Creative Commons Attribution 2.0 Contributors: David Mellis
Image:Arduino Due.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Due.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors: User:JackStonePGD
Image:LilyPad Arduino Main Board.JPG Source: http://en.wikipedia.org/w/index.php?title=File:LilyPad_Arduino_Main_Board.JPG License: Creative Commons Attribution-Sharealike 2.0
Contributors: FlickreviewR, Leoboudv, WikiEditingResearcher
Image:Arduino Protoboard Shields.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Protoboard_Shields.jpg License: Creative Commons Attribution-Sharealike 2.0
Contributors: Marlon J. Manrique
Image:Wingshield on Arduino - ARSH-05-WI.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Wingshield_on_Arduino_-_ARSH-05-WI.jpg License: Creative Commons
Attribution-Sharealike 2.0 Contributors: oomlout
Image:Adafruit Motor Shield - ARSH-02-MS 01.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Adafruit_Motor_Shield_-_ARSH-02-MS_01.jpg License: Creative Commons
Attribution-Sharealike 2.0 Contributors: oomlout
Image:ARSH-09-DL 03.jpg Source: http://en.wikipedia.org/w/index.php?title=File:ARSH-09-DL_03.jpg License: Creative Commons Attribution-Sharealike 2.0 Contributors: oomlout
File:Arduino 1.0 IDE, Ubuntu 11.10.png Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_1.0_IDE,_Ubuntu_11.10.png License: GNU Free Documentation License
Contributors: Lemio
File:Arduino led-5.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_led-5.jpg License: Public Domain Contributors: DustyDingo
Image:Mck glamor 320.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Mck_glamor_320.jpg License: Creative Commons Attribution 3.0 Contributors: MakeThings LLC
Image:Arduino Diecimila.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Diecimila.jpg License: GNU Free Documentation License Contributors: Franky47
File:MOS KIM-1 IMG 4211 cropped scale.jpg Source: http://en.wikipedia.org/w/index.php?title=File:MOS_KIM-1_IMG_4211_cropped_scale.jpg License: Creative Commons
Attribution-Sharealike 2.0 Contributors: MOS_KIM-1_IMG_4211.jpg: re-framing: Tomer T (talk) scale:
Image:KL Intel D8749.jpg Source: http://en.wikipedia.org/w/index.php?title=File:KL_Intel_D8749.jpg License: GNU Free Documentation License Contributors: Konstantin Lanzet
Image:Pickit1 devboard.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Pickit1_devboard.jpg License: Copyrighted free use Contributors: User:Dhenry
Image:DwengoBoard.jpg Source: http://en.wikipedia.org/w/index.php?title=File:DwengoBoard.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors: WimHeirman
Image:ATmega8 01 Pengo.jpg Source: http://en.wikipedia.org/w/index.php?title=File:ATmega8_01_Pengo.jpg License: unknown Contributors: Pengo
Image:AVR ATXMEGA 128A1.JPG Source: http://en.wikipedia.org/w/index.php?title=File:AVR_ATXMEGA_128A1.JPG License: Creative Commons Attribution 3.0 Contributors:
File:Atmel STK 500 DSC00557 wp.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Atmel_STK_500_DSC00557_wp.jpg License: GNU Free Documentation License Contributors:
smial (talk)
Image:Isp headers.svg Source: http://en.wikipedia.org/w/index.php?title=File:Isp_headers.svg License: Creative Commons Attribution 3.0 Contributors: User:Osiixy
Image:AvrDragon.png Source: http://en.wikipedia.org/w/index.php?title=File:AvrDragon.png License: GNU Free Documentation License Contributors: User:Jim1138
Image:ATmega169-MLF.jpg Source: http://en.wikipedia.org/w/index.php?title=File:ATmega169-MLF.jpg License: GNU Free Documentation License Contributors: Achim Raschka, Bomazi,
DustyDingo, 1 anonymous edits
Image:Arduino Duemilanove 0509.JPG Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Duemilanove_0509.JPG License: Public Domain Contributors: Minime72706
Image:Atmega8 Development Board.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Atmega8_Development_Board.jpg License: Creative Commons Attribution-Sharealike 3.0
Contributors: Andy Dingley, Bomazi, Denniss, Dhx1, Jameslwoodward, Magog the Ogre
File:Open Source Hardware (OSHW) Logo on blank PCB.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Open_Source_Hardware_(OSHW)_Logo_on_blank_PCB.jpg License:
Creative Commons Attribution-Sharealike 3.0 Contributors: User:Altzone
File:RepRap_'Mendel'.jpg Source: http://en.wikipedia.org/w/index.php?title=File:RepRap_'Mendel'.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors: CharlesC
File:Arduino Diecimila.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Diecimila.jpg License: GNU Free Documentation License Contributors: Franky47
File:Arduino Leonardo.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Leonardo.jpg License: Creative Commons Attribution-Sharealike 2.0 Contributors: Jeremy Blum
File:Arduino-uno-perspective-whitw.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino-uno-perspective-whitw.jpg License: Creative Commons Attribution 2.0 Contributors:
Arduino-uno-perspective.jpg: Creative Tools derivative work: JotaCartas (talk)
File:Arduino Mega2560.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Mega2560.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors: Andy
File:Arduino Ethernet Board .jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Ethernet_Board_.jpg License: Creative Commons Attribution-Sharealike 2.0 Contributors:
File:Arduino Fio.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Fio.jpg License: Creative Commons Attribution 2.0 Contributors: David Mellis
File:Arduino Nano.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Nano.jpg License: Creative Commons Attribution 2.0 Contributors: David Mellis
File:Flexible Lilypad Arduino.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Flexible_Lilypad_Arduino.jpg License: Creative Commons Attribution-Sharealike 2.0 Contributors:
FlickreviewR, Steven Walling, 2 anonymous edits
File:Arduino Pro.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Pro.jpg License: Creative Commons Attribution 2.0 Contributors: David Mellis
File:Arduino Micro.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Micro.jpg License: Creative Commons Attribution-Sharealike 3.0,2.5,2.0,1.0 Contributors: Geek3
File:Arduino Mini.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Mini.jpg License: Creative Commons Attribution 2.0 Contributors: David Mellis
File:A hand-soldered Arduino.jpg Source: http://en.wikipedia.org/w/index.php?title=File:A_hand-soldered_Arduino.jpg License: Creative Commons Attribution-Sharealike 2.0 Contributors:
Matt Biddulph
File:Arduino top-1.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_top-1.jpg License: Public Domain Contributors: DustyDingo
File:Arduino BT.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_BT.jpg License: Creative Commons Attribution 2.0 Contributors: David Mellis
File:Flamingo Arduino.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Flamingo_Arduino.jpg License: Creative Commons Attribution-Sharealike 2.0 Contributors: Alcohol Wang
Image Sources, Licenses and Contributors
File:Limited-edition orange Arduino Duemilanove.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Limited-edition_orange_Arduino_Duemilanove.jpg License: Creative Commons
Attribution-Sharealike 2.0 Contributors: Matt Biddulph
File:Arduino Mega 2.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Arduino_Mega_2.jpg License: Creative Commons Attribution-Sharealike 2.0 Contributors: oomlout
File:AVRduinoUplus.jpg Source: http://en.wikipedia.org/w/index.php?title=File:AVRduinoUplus.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors: Slicmicro
File:SainSmart UNO.JPG Source: http://en.wikipedia.org/w/index.php?title=File:SainSmart_UNO.JPG License: Creative Commons Attribution-Sharealike 3.0 Contributors:
File:SainSmart Mega2560.JPG Source: http://en.wikipedia.org/w/index.php?title=File:SainSmart_Mega2560.JPG License: Creative Commons Attribution-Sharealike 3.0 Contributors:
File:SainSmart UNO R3.JPG Source: http://en.wikipedia.org/w/index.php?title=File:SainSmart_UNO_R3.JPG License: Creative Commons Attribution-Sharealike 3.0 Contributors:
File:Brasuino BS1.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Brasuino_BS1.jpg License: Creative Commons Attribution-Sharealike 2.0 Contributors: Gustavo Noronha
File:BatBox2.jpg Source: http://en.wikipedia.org/w/index.php?title=File:BatBox2.jpg License: Creative Commons Attribution 2.0 Contributors: Windell Oskay
File:SB-Freeduino v2.3.jpg Source: http://en.wikipedia.org/w/index.php?title=File:SB-Freeduino_v2.3.jpg License: Creative Commons Attribution 2.0 Contributors: Solarbotics
File:DFRobotRomeo.jpg Source: http://en.wikipedia.org/w/index.php?title=File:DFRobotRomeo.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors: Dfrobot
File:DFRobot Arduino.jpg Source: http://en.wikipedia.org/w/index.php?title=File:DFRobot_Arduino.jpg License: Creative Commons Attribution-Sharealike 2.0 Contributors: Alcohol Wang
File:Seeeduino Perspective view.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Seeeduino_Perspective_view.jpg License: Creative Commons Attribution-Sharealike 2.0
Contributors: Seeed Studio
File:TwentyTen.jpg Source: http://en.wikipedia.org/w/index.php?title=File:TwentyTen.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors: JonOxer, 1 anonymous edits
File:Zigduino-kit.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Zigduino-kit.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors: Rocketgeek
File:Faraduino.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Faraduino.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors: Andy Dingley
File:Faraduino buggy.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Faraduino_buggy.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors: Andy Dingley
File:Motoruino.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Motoruino.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors: Andy Dingley
File:Boarduino.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Boarduino.jpg License: Creative Commons Attribution 2.0 Contributors: Limor
File:Freeduino-usb-mega-2560.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Freeduino-usb-mega-2560.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors:
File:Freeduino-nano.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Freeduino-nano.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors: User:Sharya77
File:Femtoduino PCB vs Dime.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Femtoduino_PCB_vs_Dime.jpg License: Creative Commons Attribution-Sharealike 3.0
Contributors: Aalbino
File:Jeenode-v6.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Jeenode-v6.jpg License: Creative Commons Attribution 3.0 Contributors: User:Jcwippler
File:MoteinoR4.jpg Source: http://en.wikipedia.org/w/index.php?title=File:MoteinoR4.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors: User:Felixemman
File:OpenTagBack.png Source: http://en.wikipedia.org/w/index.php?title=File:OpenTagBack.png License: Creative Commons Attribution-Sharealike 3.0 Contributors: User:Dascyllus
File:OpenTagfront.png Source: http://en.wikipedia.org/w/index.php?title=File:OpenTagfront.png License: Creative Commons Attribution-Sharealike 3.0 Contributors: User:Dascyllus
File:Sanguino v1.0.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Sanguino_v1.0.jpg License: Creative Commons Attribution-Sharealike 2.0 Contributors: Zach Hoeken
File:SODAQ.jpg Source: http://en.wikipedia.org/w/index.php?title=File:SODAQ.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors: User:Sodaq
File:TinyDuinoThumbnail.jpg Source: http://en.wikipedia.org/w/index.php?title=File:TinyDuinoThumbnail.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors:
File:TinyLilyThumbnail.png Source: http://en.wikipedia.org/w/index.php?title=File:TinyLilyThumbnail.png License: Creative Commons Attribution-Sharealike 3.0 Contributors:
File:EmonTx V2.0.png Source: http://en.wikipedia.org/w/index.php?title=File:EmonTx_V2.0.png License: Creative Commons Attribution-Sharealike 3.0 Contributors: Armbrust, Gins90,
File:PANSTAMP.JPG Source: http://en.wikipedia.org/w/index.php?title=File:PANSTAMP.JPG License: Creative Commons Attribution 3.0 Contributors: Estratos
File:Leaflabs Maple OSHW with STM32F103RBT6 MCU.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Leaflabs_Maple_OSHW_with_STM32F103RBT6_MCU.jpg License:
Creative Commons Attribution-Sharealike 3.0 Contributors: User:Viswesr
File:Myfreescalewebpage theuno.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Myfreescalewebpage_theuno.jpg License: Public Domain Contributors: Jojo69003
File:Myfreescalewebpage bigbrother.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Myfreescalewebpage_bigbrother.jpg License: Creative Commons Zero Contributors:
File:Myfreescalewebpage bigbrother usb.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Myfreescalewebpage_bigbrother_usb.jpg License: Creative Commons
Attribution-Sharealike 3.0 Contributors: User:Jojo69003
File:Thin Layer Embedded Goldilocks FPGA Development Board.jpg Source:
http://en.wikipedia.org/w/index.php?title=File:Thin_Layer_Embedded_Goldilocks_FPGA_Development_Board.jpg License: Creative Commons Attribution-Sharealike 3.0 Contributors:
File:Thin Layer Breadstick FPGA Dev Board.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Thin_Layer_Breadstick_FPGA_Dev_Board.jpg License: Creative Commons
Attribution-Sharealike 3.0 Contributors: Brentsinger
file:Commons-logo.svg Source: http://en.wikipedia.org/w/index.php?title=File:Commons-logo.svg License: logo Contributors: Anomie
File:Processing Logo Clipped.svg Source: http://en.wikipedia.org/w/index.php?title=File:Processing_Logo_Clipped.svg License: Creative Commons Attribution 3.0 Contributors: Woodmath
File:Processing-1.2.1.png Source: http://en.wikipedia.org/w/index.php?title=File:Processing-1.2.1.png License: GNU General Public License Contributors: Ben Fry and Casey Reas
File:Processing-sketch jun11a.png Source: http://en.wikipedia.org/w/index.php?title=File:Processing-sketch_jun11a.png License: Creative Commons Zero Contributors: User:Joosep-Georg
Creative Commons Attribution-Share Alike 3.0