We only need one thing to complete this recipe—a computer connected to the Internet.

Follow these simple steps:

Now that we have the Arduino IDE installed, let's familiarize ourselves with the user interface.

Here is a screenshot of the Arduino software running on Windows. It looks the same on Mac and Linux, since it's all written in Java.

First, we will discuss the Tool Bar. In the Tool Bar, we can find the most used buttons:

Button	Description
	The Verify button compiles the code and checks it for errors.
	The Upload button compiles the code and, if there is no error in the code, uploads it to the Arduino board.
	The New button starts a new program. In the Arduino world, programs are called sketches.
	The Open button simply allows us to open a saved sketch.
	The Save button saves the current sketch.
	This button opens the Serial Monitor window that allows us to communicate with the Arduino board. It is extremely helpful when we debug a program. More information can be found in the Serial output recipe in Chapter 7, Digital Communication with Arduino

In the Sketch tab, we can see all the opened Arduino Sketches. This comes handy when we want to work on multiple programs at the same time.

The Code Space area is where all the magic happens. That's where we write the code that powers satellites and cat food dispensers. It's a code editor with automatic syntax highlighting and autoarranging.

The Status Display area indicates all the bad stuff. Whenever there are errors in the code, they will be displayed there. It also displays errors in the connection with the board. The only good thing it can display is that the code has been successfully uploaded to the Arduino board.

Additional functionality can be found in the main menu bar. Here, we have the classic File menu where we have Save, Open, Close, and also some examples. In the following recipes, more will be discussed about the menu bar components. A nice trick worth sharing is in the Tools menu—the Auto Format tool will format the code to look professional and clean.

Consider the following recipes to better understand how to use the Arduino software environment:

The following are the ingredients required for this recipe:

This recipe is split in two, as the steps for Mac and Windows are slightly different.

The procedure for an Ubuntu Linux computer is at http://playground.arduino.cc/Linux/Ubuntu.

To execute this recipe, the following are the components required:

Follow these steps:

When we upload a sketch to the board, the Arduino software first compiles the code. If there is an error in the code, it will write it in the Status Display area and will stop the upload. If no errors are found, it will begin writing the compiled code to the board. Errors will appear if the board or serial port is not properly selected. When everything is correctly set up, the TX RX LEDs will blink, meaning data is being transferred between the computer and the Arduino board. When the transfer is done, the board will reset and the code will immediately begin executing.

The code is stored in the Arduino board until it is erased or replaced by another code. We can take the board and plug it into a battery or to another computer, and it will still execute this blinking.

To execute this recipe, we need just one ingredient: the Arduino IDE running on a computer.

These are the two mandatory functions in the Arduino coding environment:

void setup() {
  // Only execute once when the Arduino boots
}


void loop(){
  // Code executes top-down and repeats continuously
}

Each Arduino sketch has two mandatory functions: the setup() function and the loop() function. The setup() function only executes once: either when we apply power to the Arduino or when it resets. Usually, we use this function to configure the pins of the Arduino, to start communication protocols, such as serial communication, or to perform actions we only want to perform once when the Arduino boots.

The loop() function executes continuously. Code in this function is executed top-down; when it reaches the end of the function, it jumps back to the start and runs again. This happens forever until the Arduino is switched off. In here, we write the code we want to run continuously.

Continue the Arduino code basics with the following recipe, Code basics: Arduino C.

Ensure that you have the Arduino IDE running on a computer.

Here is a simple example of basic Arduino C/C++ manipulating two variables:

// Global Variables
int var1 = 10;
int var2 = 20;

void setup() {
  // Only execute once when the Arduino boots
  var2 = 5; // var2 becomes 5 once the Arduino boots
}


void loop(){
  // Code executes top-down and repeats continuously
  if (var1 > var2){ // If var1 is greater than var2
    var2++; // Increment var2 by 1
  } else { // If var1 is NOT greater than var2
    var2 = 0; // var2 becomes 0
  }
}

The code plays with two integer variables. Here we have a code breakdown to better explain each step.

First, we declared two global variables—var1 and var2—and we set them to the values of 10 and 20 respectively.

// Global Variables
int var1 = 10;
int var2 = 20;

When the Arduino boots, it first allocates the global variables into memory. In the setup() function, we change the value of var2 to 5:

void setup() {
  // Only execute once when the Arduino boots
  var2 = 5; // var2 becomes 5 once the Arduino boots
}

After the Arduino allocates the global variables, it executes the code inside the setup() function once. Following this, the loop() function will execute repeatedly. Inside, we have an if condition that will play with the values of var2. If var1 is greater than var2, we increase var2 by one. Eventually, var1 will not be greater than var2, and then we set var2 to 0. This will result in an infinite adding and equaling of var2.

This is one example on how the Arduino executes the code in its two main functions.

Continue the Arduino code basics with the following recipe, Code basics – Arduino pins.

For this recipe, ensure that you have the Arduino IDE running on a computer.

The following code turns a pin HIGH and LOW repeatedly while reading the external voltage applied to another:

void setup() {
  // Set pin 2 as a digital Output
  pinMode(2, OUTPUT);
  // Set pin 3 as a digital Input
  pinMode(3, INPUT);
}

void loop(){
    // Set pin 2 HIGH
  digitalWrite(2, HIGH);
  // Wait 100 milliseconds
  delay(100);
  // Set pin 2 LOW
  digitalWrite(2, LOW);
  // Wait 100 milliseconds
  delay(100);
    // Read the value of pin 3 and store it in a variable
  int pinValue = digitalRead(3);
}

The code sets two pins in output and input mode and then writes and reads from them. Here is the code breakdown:

In setup(), we use the pinMode() function to set pin number 2 as an output. When we set a pin as an output, we can set that pin as either HIGH (5 V) or LOW (0 V). Also, we set pin number 3 as an input. A pin configured as input can read external voltages applied to it. It can read HIGH if the voltage is around 5 V and LOW if the voltage is close or equal to 0 V:

void setup() {
  // Set pin 2 as a digital Output
  pinMode(2, OUTPUT);
  // Set pin 3 as a digital Input
  pinMode(3, INPUT);
}

In the loop() function, we use the digitalWrite() function to set pin number 2 to HIGH. Then, we wait for 100 milliseconds using the delay() function. This function stops the execution of the code for the specified time, in milliseconds. Thereafter, we set the pin to LOW and wait another 100 milliseconds. In the end, we read the value of pin 3 in a variable:

void loop(){
  
  // Set pin 2 HIGH
  digitalWrite(2, HIGH);
  // Wait 100 milliseconds
  delay(100);
  // Set pin 2 LOW
  digitalWrite(2, LOW);
  // Wait 100 milliseconds
  delay(100);
  
  // Read the value of pin 3 and store it in a variable
  int pinValue = digitalRead(3);
}