Arduino Uno Board

Arduino is a single-board microcontroller meant to make the application more accessible which
are interactive objects and its surroundings. The hardware features with an open-source hardware
board designed around an 8-bit Atmel AVR microcontroller or a 32-bit Atmel ARM. Current
models consists a USB interface, 6 analog input pins and 14 digital I/O pins that allows the user
to attach various extension boards.

The Arduino Uno board is a microcontroller based on the ATmega328. It has 14 digital
input/output pins in which 6 can be used as PWM outputs, a 16 MHz ceramic resonator, an
ICSP header, a USB connection, 6 analog inputs, a power jack and a reset button. This
contains all the required support needed for microcontroller. In order to get started, they
are simply connected to a computer with a USB cable or with a AC-to-DC adapter or
battery. Arduino Uno Board varies from all other boards and they will not use the FTDI
USB-to-serial driver chip in them. It is featured by the Atmega16U2 (Atmega8U2 up to
version R2) programmed as a USB-to-serial converter.

Arduino Uno with Digital Input/Output

There are various types of Arduino boards in which many of them were third-party
compatible versions. The most official versions available are the Arduino Uno R3 and the
Arduino Nano V3. Both of these run a 16MHz Atmel ATmega328P 8-bit microcontroller
with 32KB of flash RAM 14 digital I/O and six analogue I/O and the 32KB will not sound
like as if running Windows. Arduino projects can be stand-alone or they can communicate
with software on running on a computer. For e.g. Flash, Processing, Max/MSP). The board
is clocked by a 16 MHz ceramic resonator and has a USB connection for power and
communication. You can easily add micro SD/SD card storage for bigger tasks.

Features of the Arduino Uno Board:

 It is an easy USB interface. This allows interface with USB as this is like a serial
device.
The chip on the board plugs straight into your USB port and supports on your
computer as a virtual serial port. The benefit of this setup is that serial
communication is an extremely easy protocol which is time-tested and USB makes
connection with modern computers and makes it comfortable.
It is easy-to-find the microcontroller brain which is the ATmega328 chip. It has
more number of hardware features like timers, external and internal interrupts,
PWM pins and multiple sleep modes.
It is an open source design and there is an advantage of being open source is that it
has a large community of people using and troubleshooting it. This makes it easy to
help in debugging projects.
It is a 16 MHz clock which is fast enough for most applications and does not speeds
up the microcontroller.
It is very convenient to manage power inside it and it had a feature of built-in
voltage regulation. This can also be powered directly off a USB port without any
external power. You can connect an external power source of upto 12v and this
regulates it to both 5v and 3.3v.
13 digital pins and 6 analog pins. This sort of pins allows you to connect hardware to
your Arduino Uno board externally. These pins are used as a key for extending the
computing capability of the Arduino Uno into the real world. Simply plug your
electronic devices and sensors into the sockets that correspond to each of these pins
and you are good to go.
This has an ICSP connector for bypassing the USB port and interfacing the Arduino
directly as a serial device. This port is necessary to re-bootload your chip if it
corrupts and can no longer used to your computer.
It has a 32 KB of flash memory for storing your code.
An on-board LED is attached to digital pin 13 to make fast the debugging of code
and to make the debug process easy.
Finally, it has a button to reset the program on the chip.

Arduino was created in the year 2005 by two Italian engineers David Cuartielles and
Massimo Banzi with the goal of keeping in mind about students to make them learn how to
program the Arduino uno microcontroller and improve their skills about electronics and
use it in the real world.

Arduino uno microcontroller can sense the environment by receiving input from a variety
of sensors and can affect its surroundings by controlling lights, motors, and other
actuators. The microcontroller is programmed using the Arduino programming language
(based on Wiring) and the Arduino development environment (based on Processing).

Programming:

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
 The Arduino Uno board can be programmed with the Arduino software.
Select Arduino Uno from the Tools > Board menu (according to the
microcontroller on your board).
The ATmega328 on the Arduino Uno comes preburned with a bootloader that
allows you to upload new code to it without the use of an external hardware
programmer. It communicates using the original STK500 protocol.
You can also bypass the bootloader and program the microcontroller through the
ICSP (In-Circuit Serial Programming) header.
The ATmega16U2 (or 8U2 in the rev1 and rev2 boards) firmware source code is
available .

Pin Diagram of Arduino Uno

The ATmega16U2/8U2 is loaded with a DFU bootloader, which can be activated by:

On Rev1 boards: connecting the solder jumper on the back of the board (near the
map of Italy) and then resetting the 8U2.
On Rev2 or later boards: there is a resistor that pulling the 8U2/16U2 HWB line to
ground, making it easier to put into DFU mode.

You can then use Atmels FLIP software (Windows) or the DFU programmer (Mac OS X
and Linux) to load a new firmware. Or you can use the ISP header with an external
programmer (overwriting the DFU bootloader).

Arduino Uno Starter Kit

Microcontroller ATmega328
Operating Voltage 5V
Input Voltage (recommended) 7-12V
Input Voltage (limits) 6-20V
Digital I/O Pins 14 (of which 6 provide PWM output)
Analog Input Pins 6
DC Current per I/O Pin 40 Ma
DC Current for 3.3V Pin 50 Ma
Flash Memory 32 KB (ATmega328) of which 0.5 KB used by
bootloader
SRAM 2 KB (ATmega328)
EEPROM 1 KB (ATmega328)
Clock Speed 16 MHz

Real-Time Applications of Arduino Uno Board

Arduino Based Home Automation System

The project is designed by using Arduino uno board for the development of home
automation system with Bluetooth which is remotely controlled and operated by an
Android OS smart phone. Houses are becoming smarter and well developed by using such
kind of advanced technologies. Modern houses are gradually increasing the way of design
by shifting to centralized control system with remote controlled switches instead of
conventional switches.

Arduino Based Home Automation

In order to achieve this, a Bluetooth module is interfaced to the Arduino Uno board at the
receiver end while on the transmitter end, a Graphical User Interface application on the
cell phone sends ON/OFF commands to the receiver where loads are connected. By
touching the identified location on the Graphical User Interface, lamps are used as loads in
this project can be turned ON/OFF remotely by using this technology. The loads are
operated by using Arduino Uno board through thyristors using triacs and OPTO-Isolators.

Arduino based Auto Intensity Control of Street Lights

As the intensity is cannot be controlled by using High Intensity Discharge (HID) lamps
power saving is not possible in street lights with these lamps as the density on roads is
decreasing from peak hours of nights to early morning.

Arduino Based Auto Intensity Control

Thus, this system overcomes this problem by controlling the intensity of LED lights on
street by gradually reducing intensity by controlling the voltage applied to these lamps.
This system uses arduino board to produce PWM pulses and it is programmed in such a
way that it decreases the voltage applied to these lamps gradually till late nights and
completely shutdowns at morning.

Thus, Arduino development board can sense the environment by receiving input from
different sensors and affects its surroundings by controlling motors, lights and other
actuators. The microcontroller on the board is programmed using the Arduino
programming language. Thanks for your attention to this article and clarify doubts about
Arduino projects by commenting below.

Arduino is a prototype platform (open-source) based on an easy-to-use hardware and software. It

consists of a circuit board, which can be programed (referred to as a microcontroller) and a
ready-made software called Arduino IDE (Integrated Development Environment), which is used
to write and upload the computer code to the physical board.

The key features are

Arduino boards are able to read analog or digital input signals from different sensors and
turn it into an output such as activating a motor, turning LED on/off, connect to the cloud
and many other actions.
You can control your board functions by sending a set of instructions to the
microcontroller on the board via Arduino IDE (referred to as uploading software).
Unlike most previous programmable circuit boards, Arduino does not need an extra piece
of hardware (called a programmer) in order to load a new code onto the board. You can
simply use a USB cable.
Additionally, the Arduino IDE uses a simplified version of C++, making it easier to learn
to program.
Finally, Arduino provides a standard form factor that breaks the functions of the micro-
controller into a more accessible package.

Board Types
Various kinds of Arduino boards are available depending on different microcontrollers used.
However, all Arduino boards have one thing in common: they are programed through the
Arduino IDE.
The differences are based on the number of inputs and outputs (the number of sensors, LEDs,
and buttons you can use on a single board), speed, operating voltage, form factor etc. Some
boards are designed to be embedded and have no programming interface (hardware), which you
would need to buy separately. Some can run directly from a 3.7V battery, others need at least 5V

Power
USB

Arduino
board can
be
powered
by using
the USB
cable from
your
computer.
All you
need to do
is connect
the USB
cable to
the USB
connectio
n (1).
Power (Barrel Jack)

Arduino boards can be powered directly from the AC mains power supply by
connecting it to the Barrel Jack (2).
Voltage Regulator

The function of the voltage regulator is to control the voltage given to the Arduino
board and stabilize the DC voltages used by the processor and other elements.
Crystal Oscillator

The crystal oscillator helps Arduino in dealing with time issues. How does Arduino
calculate time? The answer is, by using the crystal oscillator. The number printed on
top of the Arduino crystal is 16.000H9H. It tells us that the frequency is 16,000,000
Hertz or 16 MHz.
Arduino Reset

You can reset your Arduino board, i.e., start your program from the beginning. You
can reset the UNO board in two ways. First, by using the reset button (17) on the
board. Second, you can connect an external reset button to the Arduino pin labelled
RESET (5).
Pins (3.3, 5, GND, Vin)

3.3V (6) Supply 3.3 output volt

5V (7) Supply 5 output volt
Most of the components used with Arduino board works fine with 3.3 volt
and 5 volt.
GND (8)(Ground) There are several GND pins on the Arduino, any of
which can be used to ground your circuit.
Vin (9) This pin also can be used to power the Arduino board from an
external power source, like AC mains power supply.

Analog pins

The Arduino UNO board has five analog input pins A0 through A5. These pins can
read the signal from an analog sensor like the humidity sensor or temperature sensor
and convert it into a digital value that can be read by the microprocessor.
Main microcontroller

Each Arduino board has its own microcontroller (11). You can assume it as the brain
of your board. The main IC (integrated circuit) on the Arduino is slightly different
from board to board. The microcontrollers are usually of the ATMEL Company. You
must know what IC your board has before loading up a new program from the
Arduino IDE. This information is available on the top of the IC. For more details
about the IC construction and functions, you can refer to the data sheet.
ICSP pin

Mostly, ICSP (12) is an AVR, a tiny programming header for the Arduino consisting
of MOSI, MISO, SCK, RESET, VCC, and GND. It is often referred to as an SPI
(Serial Peripheral Interface), which could be considered as an "expansion" of the
output. Actually, you are slaving the output device to the master of the SPI bus.
Power LED indicator

This LED should light up when you plug your Arduino into a power source to
indicate that your board is powered up correctly. If this light does not turn on, then
there is something wrong with the connection.
TX and RX LEDs

On your board, you will find two labels: TX (transmit) and RX (receive). They
appear in two places on the Arduino UNO board. First, at the digital pins 0 and 1, to
indicate the pins responsible for serial communication. Second, the TX and RX led
(13). The TX led flashes with different speed while sending the serial data. The speed
of flashing depends on the baud rate used by the board. RX flashes during the
receiving process.
 Digital I/O

The Arduino UNO board has 14 digital I/O pins (15) (of which 6 provide PWM
(Pulse Width Modulation) output. These pins can be configured to work as input
digital pins to read logic values (0 or 1) or as digital output pins to drive different
modules like LEDs, relays, etc. The pins labeled ~ can be used to generate PWM.
AREF

AREF stands for Analog Reference. It is sometimes, used to set an external reference
voltage (between 0 and 5 Volts) as the upper limit for the analog input pins.

After learning about the main parts of the Arduino UNO board, we are ready to learn how to set
up the Arduino IDE. Once we learn this, we will be ready to upload our program on the Arduino
board.

In this section, we will learn in easy steps, how to set up the Arduino IDE on our computer and
prepare the board to receive the program via USB cable.

Step 1 First you must have your Arduino board (you can choose your favorite board) and a
USB cable. In case you use Arduino UNO, Arduino Duemilanove, Nano, Arduino Mega 2560,
or Diecimila, you will need a standard USB cable (A plug to B plug), the kind you would
connect to a USB printer as shown in the following image.

In case you use Arduino Nano, you will need an A to Mini-B cable instead as shown in the
following image.
Step 2 Download Arduino IDE Software.

You can get different versions of Arduino IDE from the Download page on the Arduino Official
website. You must select your software, which is compatible with your operating system
(Windows, IOS, or Linux). After your file download is complete, unzip the file.

Step 3 Power up your board.

The Arduino Uno, Mega, Duemilanove and Arduino Nano automatically draw power from
either, the USB connection to the computer or an external power supply. If you are using an
Arduino Diecimila, you have to make sure that the board is configured to draw power from the
USB connection. The power source is selected with a jumper, a small piece of plastic that fits
onto two of the three pins between the USB and power jacks. Check that it is on the two pins
closest to the USB port.
Connect the Arduino board to your computer using the USB cable. The green power LED
(labeled PWR) should glow.

Step 4 Launch Arduino IDE.

After your Arduino IDE software is downloaded, you need to unzip the folder. Inside the folder,
you can find the application icon with an infinity label (application.exe). Double-click the icon to
start the IDE.

Step 5 Open your first project.

Once the software starts, you have two options

Create a new project.

Open an existing project example.

To create a new project, select File New.

To open an existing project example, select File Example Basics Blink.
Here, we are selecting just one of the examples with the name Blink. It turns the LED on and off
with some time delay. You can select any other example from the list.

Step 6 Select your Arduino board.

To avoid any error while uploading your program to the board, you must select the correct
Arduino board name, which matches with the board connected to your computer.

Go to Tools Board and select your board.

Here, we have selected Arduino Uno board according to our tutorial, but you must select the
name matching the board that you are using.

Step 7 Select your serial port.

Select the serial device of the Arduino board. Go to Tools Serial Port menu. This is likely to
be COM3 or higher (COM1 and COM2 are usually reserved for hardware serial ports). To find
out, you can disconnect your Arduino board and re-open the menu, the entry that disappears
should be of the Arduino board. Reconnect the board and select that serial port.
Step 8 Upload the program to your board.

Before explaining how we can upload our program to the board, we must demonstrate the
function of each symbol appearing in the Arduino IDE toolbar.
A Used to check if there is any compilation error.

B Used to upload a program to the Arduino board.

C Shortcut used to create a new sketch.

D Used to directly open one of the example sketch.

E Used to save your sketch.

F Serial monitor used to receive serial data from the board and send the serial data to the
board.

Now, simply click the "Upload" button in the environment. Wait a few seconds; you will see the
RX and TX LEDs on the board, flashing. If the upload is successful, the message "Done
uploading" will appear in the status bar.

Note If you have an Arduino Mini, NG, or other board, you need to press the reset button
physically on the board, immediately before clicking the upload button on the Arduino Software.
ARDUINO IDE

File

New
Creates a new instance of the editor, with the bare minimum structure of a sketch already
in place.
Open
Allows to load a sketch file browsing through the computer drives and folders.
Open Recent
Provides a short list of the most recent sketches, ready to be opened.
Sketchbook
Shows the current sketches within the sketchbook folder structure; clicking on any name
opens the corresponding sketch in a new editor instance.
Examples
Any example provided by the Arduino Software (IDE) or library shows up in this menu
item. All the examples are structured in a tree that allows easy access by topic or library.
Close
Closes the instance of the Arduino Software from which it is clicked.
Save
Saves the sketch with the current name. If the file hasn't been named before, a name will
be provided in a "Save as.." window.
Save as...
Allows to save the current sketch with a different name.
Page Setup
It shows the Page Setup window for printing.
Print
Sends the current sketch to the printer according to the settings defined in Page Setup.
Preferences
Opens the Preferences window where some settings of the IDE may be customized, as
the language of the IDE interface.
Quit
Closes all IDE windows. The same sketches open when Quit was chosen will be
automatically reopened the next time you start the IDE.

Edit

Undo/Redo
Goes back of one or more steps you did while editing; when you go back, you may go
forward with Redo.
Cut
Removes the selected text from the editor and places it into the clipboard.
Copy
Duplicates the selected text in the editor and places it into the clipboard.
 Copy for Forum
Copies the code of your sketch to the clipboard in a form suitable for posting to the
forum, complete with syntax coloring.
Copy as HTML
Copies the code of your sketch to the clipboard as HTML, suitable for embedding in web
pages.
Paste
Puts the contents of the clipboard at the cursor position, in the editor.
Select All
Selects and highlights the whole content of the editor.
Comment/Uncomment
Puts or removes the // comment marker at the beginning of each selected line.
Increase/Decrease Indent
Adds or subtracts a space at the beginning of each selected line, moving the text one
space on the right or eliminating a space at the beginning.
Find
Opens the Find and Replace window where you can specify text to search inside the
current sketch according to several options.
Find Next
Highlights the next occurrence - if any - of the string specified as the search item in the
Find window, relative to the cursor position.
Find Previous
Highlights the previous occurrence - if any - of the string specified as the search item in
the Find window relative to the cursor position.

Sketch

Verify/Compile
Checks your sketch for errors compiling it; it will report memory usage for code and
variables in the console area.
Upload
Compiles and loads the binary file onto the configured board through the configured Port.
Upload Using Programmer
This will overwrite the bootloader on the board; you will need to use Tools > Burn
Bootloader to restore it and be able to Upload to USB serial port again. However, it
allows you to use the full capacity of the Flash memory for your sketch. Please note that
this command will NOT burn the fuses. To do so a Tools -> Burn Bootloader command
must be executed.
Export Compiled Binary
Saves a .hex file that may be kept as archive or sent to the board using other tools.
Show Sketch Folder
Opens the current sketch folder.
Include Library
Adds a library to your sketch by inserting #include statements at the start of your code.
For more details, see libraries below. Additionally, from this menu item you can access
the Library Manager and import new libraries from .zip files.
 Add File...
Adds a source file to the sketch (it will be copied from its current location). The new file
appears in a new tab in the sketch window. Files can be removed from the sketch using
the tab menu accessible clicking on the small triangle icon below the serial monitor one
on the right side o the toolbar.

Tools

Auto Format
This formats your code nicely: i.e. indents it so that opening and closing curly braces line
up, and that the statements inside curly braces are indented more.
Archive Sketch
Archives a copy of the current sketch in .zip format. The archive is placed in the same
directory as the sketch.
Fix Encoding & Reload
Fixes possible discrepancies between the editor char map encoding and other operating
systems char maps.
Serial Monitor
Opens the serial monitor window and initiates the exchange of data with any connected
board on the currently selected Port. This usually resets the board, if the board supports
Reset over serial port opening.
Board
Select the board that you're using. See below for descriptions of the various boards.
Port
This menu contains all the serial devices (real or virtual) on your machine. It should
automatically refresh every time you open the top-level tools menu.
Programmer
For selecting a harware programmer when programming a board or chip and not using
the onboard USB-serial connection. Normally you won't need this, but if you're burning a
bootloader to a new microcontroller, you will use this.
Burn Bootloader
The items in this menu allow you to burn a bootloader onto the microcontroller on an
Arduino board. This is not required for normal use of an Arduino or Genuino board but is
useful if you purchase a new ATmega microcontroller (which normally come without a
bootloader). Ensure that you've selected the correct board from the Boards menu before
burning the bootloader on the target board. This command also set the right fuses.

Help

Here you find easy access to a number of documents that come with the Arduino Software
(IDE). You have access to Getting Started, Reference, this guide to the IDE and other documents
locally, without an internet connection. The documents are a local copy of the online ones and
may link back to our online website.
 Find in Reference
This is the only interactive function of the Help menu: it directly selects the relevant page
in the local copy of the Reference for the function or command under the cursor.

Sketchbook

The Arduino Software (IDE) uses the concept of a sketchbook: a standard place to store your
programs (or sketches). The sketches in your sketchbook can be opened from the File >
Sketchbook menu or from the Open button on the toolbar. The first time you run the Arduino
software, it will automatically create a directory for your sketchbook. You can view or change
the location of the sketchbook location from with the Preferences dialog.

Beginning with version 1.0, files are saved with a .ino file extension. Previous versions use
the .pde extension. You may still open .pde named files in version 1.0 and later, the
software will automatically rename the extension to .ino.

Tabs, Multiple Files, and Compilation

Allows you to manage sketches with more than one file (each of which appears in its own tab).
These can be normal Arduino code files (no visible extension), C files (.c extension), C++ files
(.cpp), or header files (.h).

Uploading

Before uploading your sketch, you need to select the correct items from the Tools > Board and
Tools > Port menus. The boards are described below. On the Mac, the serial port is probably
something like /dev/tty.usbmodem241 (for an Uno or Mega2560 or Leonardo) or
/dev/tty.usbserial-1B1 (for a Duemilanove or earlier USB board), or
/dev/tty.USA19QW1b1P1.1 (for a serial board connected with a Keyspan USB-to-Serial
adapter). On Windows, it's probably COM1 or COM2 (for a serial board) or COM4, COM5,
COM7, or higher (for a USB board) - to find out, you look for USB serial device in the ports
section of the Windows Device Manager. On Linux, it should be /dev/ttyACMx , /dev/ttyUSBx
or similar. Once you've selected the correct serial port and board, press the upload button in the
toolbar or select the Upload item from the Sketch menu. Current Arduino boards will reset
automatically and begin the upload. With older boards (pre-Diecimila) that lack auto-reset, you'll
need to press the reset button on the board just before starting the upload. On most boards, you'll
see the RX and TX LEDs blink as the sketch is uploaded. The Arduino Software (IDE) will
display a message when the upload is complete, or show an error.

When you upload a sketch, you're using the Arduino bootloader, a small program that has been
loaded on to the microcontroller on your board. It allows you to upload code without using any
additional hardware. The bootloader is active for a few seconds when the board resets; then it
starts whichever sketch was most recently uploaded to the microcontroller. The bootloader will
blink the on-board (pin 13) LED when it starts (i.e. when the board resets).

Libraries
Libraries provide extra functionality for use in sketches, e.g. working with hardware or
manipulating data. To use a library in a sketch, select it from the Sketch > Import Library
menu. This will insert one or more #include statements at the top of the sketch and compile the
library with your sketch. Because libraries are uploaded to the board with your sketch, they
increase the amount of space it takes up. If a sketch no longer needs a library, simply delete its
#include statements from the top of your code.

There is a list of libraries in the reference. Some libraries are included with the Arduino software.
Others can be downloaded from a variety of sources or through the Library Manager. Starting
with version 1.0.5 of the IDE, you do can import a library from a zip file and use it in an open
sketch. See these instructions for installing a third-party library.

To write your own library, see this tutorial.

Third-Party Hardware

Support for third-party hardware can be added to the hardware directory of your sketchbook
directory. Platforms installed there may include board definitions (which appear in the board
menu), core libraries, bootloaders, and programmer definitions. To install, create the hardware
directory, then unzip the third-party platform into its own sub-directory. (Don't use "arduino" as
the sub-directory name or you'll override the built-in Arduino platform.) To uninstall, simply
delete its directory.

For details on creating packages for third-party hardware, see the Arduino IDE 1.5 3rd party
Hardware specification.

Serial Monitor

Displays serial data being sent from the Arduino or Genuino board (USB or serial board). To
send data to the board, enter text and click on the "send" button or press enter. Choose the baud
rate from the drop-down that matches the rate passed to Serial.begin in your sketch. Note that on
Windows, Mac or Linux, the Arduino or Genuino board will reset (rerun your sketch execution
to the beginning) when you connect with the serial monitor.

You can also talk to the board from Processing, Flash, MaxMSP, etc (see the interfacing page for
details).

Preferences

Some preferences can be set in the preferences dialog (found under the Arduino menu on the
Mac, or File on Windows and Linux). The rest can be found in the preferences file, whose
location is shown in the preference dialog.

Language Support
Since version 1.0.1 , the Arduino Software (IDE) has been translated into 30+ different
languages. By default, the IDE loads in the language selected by your operating system. (Note:
on Windows and possibly Linux, this is determined by the locale setting which controls currency
and date formats, not by the language the operating system is displayed in.)

If you would like to change the language manually, start the Arduino Software (IDE) and open
the Preferences window. Next to the Editor Language there is a dropdown menu of currently
supported languages. Select your preferred language from the menu, and restart the software to
use the selected language. If your operating system language is not supported, the Arduino
Software (IDE) will default to English.

You can return the software to its default setting of selecting its language based on your
operating system by selecting System Default from the Editor Language drop-down. This
setting will take effect when you restart the Arduino Software (IDE). Similarly, after changing
your operating system's settings, you must restart the Arduino Software (IDE) to update it to the
new default language.

Boards
The board selection has two effects: it sets the parameters (e.g. CPU speed and baud rate) used
when compiling and uploading sketches; and sets and the file and fuse settings used by the burn
bootloader command. Some of the board definitions differ only in the latter, so even if you've
been uploading successfully with a particular selection you'll want to check it before burning the
bootloader. You can find a comparison table between the various boards here.

Arduino Software (IDE) includes the built in support for the boards in the following list, all
based on the AVR Core. The Boards Manager included in the standard installation allows to add
support for the growing number of new boards based on different cores like Arduino Due,
Arduino Zero, Edison, Galileo and so on.

Arduino Yn
An ATmega32u4 running at 16 MHz with auto-reset, 12 Analog In, 20 Digital I/O and 7
PWM.
Arduino/Genuino Uno
An ATmega328 running at 16 MHz with auto-reset, 6 Analog In, 14 Digital I/O and 6
PWM.
Arduino Diecimila or Duemilanove w/ ATmega168
An ATmega168 running at 16 MHz with auto-reset.
Arduino Nano w/ ATmega328
An ATmega328 running at 16 MHz with auto-reset. Has eight analog inputs.
Arduino/Genuino Mega 2560
An ATmega2560 running at 16 MHz with auto-reset, 16 Analog In, 54 Digital I/O and 15
PWM.
Arduino Mega
An ATmega1280 running at 16 MHz with auto-reset, 16 Analog In, 54 Digital I/O and 15
PWM.
Arduino Mega ADK
An ATmega2560 running at 16 MHz with auto-reset, 16 Analog In, 54 Digital I/O and 15
PWM.
Arduino Leonardo
An ATmega32u4 running at 16 MHz with auto-reset, 12 Analog In, 20 Digital I/O and 7
PWM.
Arduino/Genuino Micro
An ATmega32u4 running at 16 MHz with auto-reset, 12 Analog In, 20 Digital I/O and 7
PWM.
Arduino Esplora
An ATmega32u4 running at 16 MHz with auto-reset.
Arduino Mini w/ ATmega328
An ATmega328 running at 16 MHz with auto-reset, 8 Analog In, 14 Digital I/O and 6
PWM.
Arduino Ethernet
Equivalent to Arduino UNO with an Ethernet shield: An ATmega328 running at 16 MHz
with auto-reset, 6 Analog In, 14 Digital I/O and 6 PWM.
 Arduino Fio
An ATmega328 running at 8 MHz with auto-reset. Equivalent to Arduino Pro or Pro
Mini (3.3V, 8 MHz) w/ ATmega328, 6 Analog In, 14 Digital I/O and 6 PWM.
Arduino BT w/ ATmega328
ATmega328 running at 16 MHz. The bootloader burned (4 KB) includes codes to
initialize the on-board bluetooth module, 6 Analog In, 14 Digital I/O and 6 PWM..
LilyPad Arduino USB
An ATmega32u4 running at 8 MHz with auto-reset, 4 Analog In, 9 Digital I/O and 4
PWM.
LilyPad Arduino
An ATmega168 or ATmega132 running at 8 MHz with auto-reset, 6 Analog In, 14
Digital I/O and 6 PWM.
Arduino Pro or Pro Mini (5V, 16 MHz) w/ ATmega328
An ATmega328 running at 16 MHz with auto-reset. Equivalent to Arduino Duemilanove
or Nano w/ ATmega328; 6 Analog In, 14 Digital I/O and 6 PWM.
Arduino NG or older w/ ATmega168
An ATmega168 running at 16 MHz without auto-reset. Compilation and upload is
equivalent to Arduino Diecimila or Duemilanove w/ ATmega168, but the bootloader
burned has a slower timeout (and blinks the pin 13 LED three times on reset); 6 Analog
In, 14 Digital I/O and 6 PWM.
Arduino Robot Control
An ATmega328 running at 16 MHz with auto-reset.
Arduino Robot Motor
An ATmega328 running at 16 MHz with auto-reset.
Arduino Gemma

EXAMPLE

http://www.arduino.cc/en/Tutorial/Blink
*/

// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever

void loop() {
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}