Arduino - A good first step in electronics.

Arduino is an open-source prototyping platform, based on easy-to-use hardware and software. Arduino boards are capable of reading inputs - light on a sensor, a finger on a button, or a Twitter message just to name a few - and turning them into an output - activating a motor, turning on an LED, publishing something online. You can tell your board what to do by sending a set of instructions to the microcontroller on the board. To do so, you use the Arduino programming language (based on Wiring), and the Arduino Software (IDE), based on Processing.

Over the years, Arduino has been the brain of thousands of projects, from everyday objects to complex scientific instruments. A worldwide community of students, hobbyists, artists, programmers, and professionals have contributed to the community, and their efforts have added up to an incredible amount of accessible knowledge that can be of great help to anyone willing to try out and experiment with one of the boards, no matter if it's a novice, or an expert.

Arduino was born as an easy tool for fast prototyping, aimed at students without a background in electronics and programming. However, as soon as it reached a wider community, the Arduino board started changing to adapt to new needs and challenges, differentiating its offer from simple 8-bit boards to products for IoT applications, wearable, 3D printing, and embedded environments. All Arduino boards are completely open-source, empowering users to build them independently and eventually adapt them to their particular needs. The software, too, is open-source, and it is growing through the contributions of users worldwide.

The key points that make Arduino boards one of the best starting points for begginers are:

  • Low cost
  • Multi-Platform support
  • Open-Source
  • Extensible

Next, I'll cover the main boards of each type, and their specifications:

Arduino UNO:

The main board for the entry level, and in my own opinion the best to start exploring with, Arduino/Genuino Uno (Genuino is the name given to the boards outside of the USA) is a microcontroller board based on the ATmega328P. It has 14 digital input/output pins (of which 6 can be used as PWM outputs), 6 analog inputs, a 16 MHz quartz crystal, a USB connection, a power jack, an ICSP header and a reset button.

The board contains everything that is needed to support the microcontroller, thus making it very simple to start experimenting with it, just plug it to a computer via the USB cable, or power it up with and AC-to-DC adapter or battery.

The good thing is that you can play around without worrying too much about setting the board on fire; worst case scenario is that you burn down the board's chip, which can be easily replaced to start over again.

"Uno" was chosen to mark the release of Arduino Software (IDE) 1.0. Both the board and the software were the reference versions of Arduino, now evolved to newer releases. The Uno board is the first in a series of USB Arduino boards, and the reference model for the Arduino platform.

The technical specifications of this board are the following, and can be found in the Arduino Official Website:

Microcontroller ATmega328P
Operating Voltage 5V
Input Voltage (recommended) 7-12V
Input Voltage (limit) 6-20V
Digital I/O Pins 14 (of which 6 provide PWM output)
PWM Digital I/O Pins 6
Analog Input Pins 6
DC Current per I/O Pin 20 mA
DC Current for 3.3V Pin 50 mA
Flash Memory 32 KB (ATmega328P)
of which 0.5 KB used by bootloader
SRAM 2 KB (ATmega328P)
EEPROM 1 KB (ATmega328P)
Clock Speed 16 MHz
Length 68.6 mm
Width 53.4 mm
Weight 25 g

Arduino Micro:

The Arduino Micro is the succesor of the Arduino Leonardo, and, as its dimensions show, aims to bring the same functionality as the other boards, but within a very reduced space.

The Micro is based on the ATmega32U4, developed in conjunction with Adafruit. It has 20 digital input/output pins (of which 7 can be used as PWM outputs and 12 as analog inputs), a 16 MHz crystal oscillator, a micro USB connection, an ICSP header, and a reset button. The form factor of the Micro enables it to be easily placed on a breadboard.

The Micro board is similar to the Arduino Leonardo in that the ATmega32U4 has built-in USB communication, eliminating the need for a secondary processor. This allows the Micro to appear to a connected computer as a mouse and keyboard, in addition to a virtual (CDC) serial / COM port.

The technical specifications for the Arduino Micro are the following:

Microcontroller ATmega32U4
Operating Voltage 5V
Input Voltage (recommended) 7-12V
Input Voltage (limit) 6-20V
Digital I/O Pins 20
PWM Channels 7
Analog Input Channels 12
DC Current per I/O Pin 20 mA
DC Current for 3.3V Pin 50 mA
Flash Memory 32 KB (ATmega32U4)
of which 4 KB used by bootloader
SRAM 2.5 KB (ATmega32U4)
EEPROM 1 KB (ATmega32U4)
Clock Speed 16 MHz
Length 48 mm
Width 18 mm
Weight 13 g

Arduino MEGA:

Escalating the level of complexity and performance, we encounter the Arduino Mega 2560, which is the replacement for the traditional Arduino Mega.

The Mega 2560 is a microcontroller board based on the ATmega2560. It counts with 54 digital input/output pins (of which 15 can be used as PWM outputs), 16 analog inputs, 4 UARTs (hardware serial ports), a 16 MHz crystal oscillator, a USB connection, a power jack, an ICSP header, and a reset button. Just like the Arduino UNO, plug it to your computer via USB, or power it up with an adapter or battery to get started. The Mega 2560 board is compatible with most shields* designed for the Uno and the former boards Duemilanove or Diecimila.
* The Shields are extension boards that aim to add more functionality to the Arduino by simply being plugged on top of it. For example, you can use a shield to add the ability to send and receive an SMS message or a phone call.

Technical specifications for the Arduino Mega 2560:

Microcontroller ATmega2560
Operating Voltage 5V
Input Voltage (recommended) 7-12V
Input Voltage (limit) 6-20V
Digital I/O Pins 54 (Of which 15 provide PWM output)
Analog Input Pins 16
DC Current per I/O Pin 20 mA
DC Current for 3.3V Pin 50 mA
Flash Memory 256 KB
of which 8 KB used by bootloader
SRAM 8 KB
EEPROM 4 KB
Clock Speed 16 MHz
Length 101.52 mm
Width 53.3 mm
Weight 37 g

Arduino GEMMA:

With the growing extension of wearable gear, Arduino has not been the exception on this field, launching tiny boards such as the GEMMA, to cover the need for wearable microcontrollers. The GEMMA comes in a 1'' diameter package, which will allow you to realize any kind of wearable project with this tiny board.

It's a microcontroller board made by Adafruit based on the ATtiny85. It has 3 digital input/output pins (of which 2 can be used as PWM outputs and 1 as analog input), an 8 MHz resonator, a micro USB connection, a JST connector for a 3.7V battery, and a reset button. It's worth mentioning that even though you can program GEMMA using the Arduino IDE, it's not a fully 100% Arduino UNO-compatible. There are some things you trade off for it's small size and low cost:

  • GEMMA does not have a Serial port connection for debugging so the serial port monitor will not be able to send/receive data.
  • Some computers' USB v3 ports don't recognize the GEMMAs bootloader. Simply use a USB v2 port or a USB hub in between.

Technical specifications for the Gemma:

Microcontroller ATtiny85
Operating Voltage 3.3V
Input Voltage 4-16V
Digital I/O Pins 3
PWM Channels 2
Analog Input Channels 1
DC Current per I/O Pin 20 mA
Absorption 9 mA while running
Flash Memory 8 KB (ATtiny85)
of which 2.75 KB used by bootloader
SRAM 512 Bytes (ATtiny85)
EEPROM 512 Bytes (ATtiny85)
Clock Speed 8 MHz
Diameter 27.94 mm

With these examples, the most used Arduino boards are covered. You can find tons of examples and user experiences around the Internet, such as robots, keyboards, switches, alarms, sensors and a lot more. Look for a few examples, and don't forget to check out the official website for more specific data, and information on the other boards available.

To end the post, I'll cover the most important task you have once you get your Arduino, programming it.

In order to start programming your board, you first need to download the Arduino Software IDE, which is cross-platform, and can be downloaded for free here. Once you are all set, you can start making your own instructions for the board, or check out one of the many examples the IDE has ready for you, under the File, Examples menu. These examples cover all of the basic Arduino commands, so it's a good starting point for a first experience.

As a very basic example, I'll show you how to turn on and off a LED light every ten seconds:

Every Arduino program counts mainly on two functions, the setup() and the loop() functions. setup() runs once, when you press the power button on your board and it initializes. Inside this function you should do all the previous steps needed that should be done only once, for example, setting the mode for the pins used.

On the other hand, the loop() function, as its name shows, runs forever as long as the board has power, executing all the instructions inside of it. Here you should declare all the instructions that you need the board to execute constantly, like reading an input, waiting for a value to change, or perform a certain action after an interval of time. This brings us to the example, which code is very simple, but yet shows how easy it is to get started with Arduino.

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

// the loop function runs over and over again forever
void loop() {
  digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)
  delay(10000); // wait for ten seconds
  digitalWrite(13, LOW); // turn the LED off by making the voltage LOW
  delay(10000); // wait for ten seconds
}

In this hypothetical example, we have connected an LED to the board, one end to a GND pin, and the other to the pin number 13. In the setup function we let the board know that it will be giving out power through that pin, setting its mode to OUTPUT, and in the loop function we tell it to send power, just by writing the value HIGH on it, then wait ten seconds (or 10000 milliseconds), and stop giving out power, again, just by writing the value LOW on the pin. One more delay of 10 seconds is instructed, because this function will start again from the beginning as soon as it ends, so without this delay, the LED would turn itself on instantly after it's been turned off.
And that's it, with just five lines of code you have a functional program that makes a light turn on and off. This is a very basic program, but clearly shows that when you get used to programming the Arduino boards, you can achieve many things.

Last but not least, if you feel ready to start coding, here's an official link that will be of great help to start getting to know the syntax, structures, and commands you can use to make your board do whatever you wish.