Your fondness for an operating system is developed due to multiple factors, and you can never ignore someone's bias towards a particular OS. Thus, this book provides installation and configuration guidelines for three of the most popular operating systems: Linux, Mac OS X, and Windows. Let's begin by configuring Python for a Linux computer.

The majority of Linux distributions come with Python preinstalled. To check the latest version of the installed Python, use the following command at the terminal window:

$ python -V

Make sure that you are using an uppercase V as the option for the previous command. Once you execute it on the terminal, it will print the complete version number of your current Python installation. If the version is 2.7.x, you are good to go and your Linux is updated with the latest version of Python that is required for this book. However, if you have any version that is less than or equal to 2.6.x, you will need to first upgrade Python to the latest version. This process will require root privileges, as Python will be installed as a system component that will replace the previous versions.

$ sudo apt-get update && sudo apt-get --only-upgrade install python

$ sudo add-apt-repository ppa:fkrull/deadsnakes
$ sudo apt-get update
$ sudo apt-get install python2.7

$ sudo yum upgrade python

Installation and configuration of Python on Windows is not as straightforward as it is for Linux. First of all, you'll need to download a copy of Python from http://www.python.org/getit.

You need to be careful about the version of Python that you are downloading. From the system properties of your Windows OS, check whether the operating system is of 32 bit or 64 bit. At the time this book was being written, the latest version of Python was 2.7.6. So, download the latest available version of Python, but make sure that it is 2.7.x and not 3.x.

For many third-party Python libraries, the installation binary files for Windows are compiled for the 32-bit version. Due to this reason, we will recommend that you install the 32-bit version of Python for your Windows OS.

If you are really familiar with Python and know your way around installing libraries, you can install the 64-bit version of Python. Select and run the downloaded file to install Python. Although you can install it to any custom location, it is advisable to use the default installation location as the upcoming configuration steps use the default location. Once the installation is complete, you can find the Python command-line tool and IDLE (Python GUI) from the Start menu.

Although you can always open these tools from the Start menu for basic scripting, we will modify the Windows system parameters to make Python accessible through the Windows command prompt. To accomplish this, we will have to set up PATH in environment variables for the location of the Python installation directory. Let's open System Properties by right-clicking on My Computer and then selecting Properties. Otherwise, you can also navigate to Start | Control Panel | System and Security | System.

You will be able to see a window similar to the one that is displayed in the following screenshot. The System window shows you the basic information about your computer, including the type of Windows operating system that you are using (such as the 32-bit or the 64-bit version):

In the System window, click on Advanced system settings in the left navigation bar to open a window called System Properties. Click on the Environment Variables… button in the System Properties window, which is located at the bottom of the window. This will open an interface similar to the one shown in the following screenshot. In Environment Variables, you need to update the PATH system variable to add Python to the default operating system's path.

Click on the PATH option as displayed in the following screenshot, which will pop up an Edit System Variable window. Add C:\Python27 or the full path of your custom Python installation directory at the end of your existing PATH variable. It is required to put a semicolon (;) before the Python installation path. If you already see Python's location in the Path variable, your system is set up for Python and you don't need to perform any changes:

The main benefit of adding Python to the environment variables is to enable access to the Python interpreter from the command prompt. In case you don't know, the Windows command prompt can be accessed by navigating to Start | Programs | Accessories | Command Prompt.

Mac OS X ships with a preinstalled copy of Python, but due to the long release cycle of the operating system, the frequency of updates for the default Python application is slow. The latest version of Mac OS X, which is 10.9 Maverick, comes equipped with Python 2.7.5, which is the latest version:

Tests-Mac:~ test$ python
Python 2.7.5 (default, Aug 25 2013, 00:04:04)
[GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

Previous versions such as Mac OS X 10.8 Mountain Lion and Mac OS X 10.7 Lion included Python 2.7.2 and Python 2.7.1 respectively, which are also compatible versions for this book. If you are an experienced Python user or someone who wants to work with the latest version of Python, you can download the latest version from http://www.python.org/getit.

Older versions of Mac OS X such as Snow Leopard and later, which came with an older version of Python, can be updated to the latest version by downloading and installing it from http://www.python.org/getit.

Setuptools is a library containing a collection of utilities for building and distributing Python packages. The most important tool from this collection is called easy_install. It allows a user to look into PyPI, the Python package repository that we mentioned previously, and provides a simple interface to install any package by name. The easy_install utility automatically downloads, builds, installs, and manages packages for the user. This utility has been used in the later part of this book to install the necessary packages required for the upcoming projects of Python and Arduino. Although easy_install has been used as a simple way of installing Python packages, it misses out on a few useful features such as tracking actions, support for uninstallation, and support for other version control systems. In recent years, the Python community has started adopting another tool called pip over easy_install that supports these features. As both easy_install and pip utilize the same PyPI repository, going forward, you can use any of these utilities to install the required Python packages.

Just to narrow down the scope, we will be focusing on methods to install Setuptools and the default utilities that get installed with it, that is, easy_install. Later in this section, we will also install pip, just in case you want to use it too. Let's first begin by installing Setuptools for the various operating systems.

$ sudo apt-get install python-setuptools

$ sudo yum install python-setuptools

$ wget https://bitbucket.org/pypa/setuptools/raw/bootstrap/ez_setup.py -O - | sudo python

> python ez_setup.py

As you have successfully installed Setuptools, let's use it to install pip. For Linux or Mac OS X, you can run the following command in the terminal to install pip:

$ sudo easy_install pip

For Windows, open the command prompt and execute the following command:

> easy_install.exe pip

If you have already installed pip on your computer, please make sure that you upgrade it to the latest version to overcome the few bugs that are associated with the upgrade. You can upgrade pip using the following command at the terminal:

$ sudo easy_install --upgrade pip

Since you have already used easy_install to install a Python package, let's get ourselves more familiar with Python package management.

With the installation of pip, you have two different options to install any third-party Python package listed on the PyPi repository (http://pypi.python.org). The following are the various procedures that you need to know to work with the installation of Python packages. In the following examples, the term PackageName is a pseudo name that is used for a Python package that you want to work with. For your package of choice, identify the appropriate package name from the PyPi website and put its name in place of PackageName. In some cases, you will need root (super user) privileges to install or uninstall a package. You can use sudo followed by an appropriate command for these cases.

To install a Python package, execute the following command at the terminal:

$ easy_install PackageName

Otherwise, you can also execute the following command:

$ pip install PackageName

If you want to install a specific version of a package, you can use the following command:

$ easy_install "PackageName==version"

If you are not aware of the exact version number, you can also use comparison operators such as >, <, >=, or <= to specify a range for the version number. Both easy_install and pip will select the best matching version of the package from the repository and install it:

$ easy_install "PackageName > version"

Meanwhile, for pip, you can use the following identical commands to perform similar operations:

$ pip install PackageName==version
$ pip install "PackageName>=version"

As an example, if you want to install a version between 1.0 and 3.0, you will need to use the following command:

$ pip install "PackageName>=0.1,<=0.3"

It is really easy to upgrade a package using either easy_install or pip. The command options used by both are also very similar:

$ easy_install --upgrade PackageName
$ pip install --upgrade PackageName

Although easy_install doesn't support clean uninstallation of a package, you can use the following command to make sure that Python stops searching for the specified package. Later, carefully remove the package files from the installation directory:

$ easy_install -mxN PackageName

A much better way to perform a clean uninstallation of the majority of packages is to use pip instead of easy_install:

$ pip uninstall PackageName

A detailed list of the Python packages supported by Setuptools can be found at the PyPI website at https://pypi.python.org/.

Python supports the usage of basic mathematical operators such as +, -, *, and /, directly from the interpreter. Using these operators, you can perform basic calculations in the prompt, as shown in the following examples. Try these operations in your prompt in order to start using the Python interpreter as a calculator:

>>> 2 + 2
4
>>> (2*3) + 1
7
>>> (2*3) / 5
1

Python is a dynamically typed language, which means that you don't have to explicitly declare the type of the variables when initializing them. When you assign a value to a variable, the Python interpreter automatically deduces the data type. For example, let's declare the following variables in the interactive mode of the interpreter:

>>> weight = height = 5
>>> weight * height
25
>>> type(weight)
<type 'int'>

While assigning the value to the weight variable, we didn't specify the data type, but the Python interpreter assigned it as an integer type, int. The interpreter assigned the int type due to the reason that the numerical value didn't contain any decimal points. Let's now declare a variable with a value containing a decimal point. The built-in function type() that can be used to find out the data type of a specified variable:

>>> length = 6.0
>>> weight * height * length
150.0
>>> type(length)
<type 'float'>

As you can see, the interpreter assigns the data type as float. The interpreter can also deduce the type of complex numbers, as shown in following examples. You can access the real and imaginary value of a complex number using the dot (.) operator followed by real and imag:

>>> val = 2.0 + 3.9j
>>> val.real
2.0
>>> val.imag
3.9

Just to play more with complex numbers, let's try the abs() and round() functions as displayed in the following examples. They are built-in Python functions to obtain the absolute value and the rounded number respectively:

>>> abs(val)
4.382921400162225
>>> round(val.imag)
4.0

Like numbers, the Python interpreter can also automatically identify the declaration of string data types. In Python, string values are assigned using single or double quotes around the value. When the interpreter sees any value enclosed within quotes, it considers it to be a string. Python supports the usage of the + operator to concatenate strings:

>>> s1 = "Hello"
>>> s2 = "World!"
>>> s1 + s2
'HelloWorld!'
>>> s1 + " " + s2
'Hello World!'

A character type is a string of size one and the individual characters of a string can be accessed by using index numbers. The first character of a string is indexed as 0. Play with the following scripts to understand indexing (subscripting) in Python:

>>> s1[0]
'H'
>>> s1[:2]
'He'
>>> s1 + s2[5:]
'Hello!'

>>> age = 14
>>> if age > 10 or age < 20:
...  print "teen"

teen

>>> myList = ['a', 2, 'b', 12.0, 5, 2]
>>> myList
['a', 2, 'b', 12.0, 5, 2]

>>> tupleA = 1, 2, 3
>>> tupleA
(1, 2, 3)
>>> tupleB = (1, 'a', 3)
>>> tupleB
(1, 'a', 3)

>>> tupleB[1]
'a'

>>> listA = [1, 2, 3, 1, 5, 2]
>>> setA = set(listA)
>>> setA
set([1, 2, 3, 5])

>>> boards = {'uno':328,'mega':2560,'lily':'128'}
>>> boards['lily']
'128'
>>> boards.keys()
['lily', 'mega', 'uno']

Just like any other language, Python supports controlling the program flow using compound statements. In this section, we will briefly introduce these statements to you. You can get detailed information about them from the official Python documentation at https://docs.python.org/2/reference/compound_stmts.html.

>>> age = 14
>>> if age < 18 and age > 12:
  print "Teen"
elif age < 13:
  print "Child"
else:
  print "Adult"

>>> celsius = [13, 21, 23, 8]
>>> for c in celsius:
  print " Fahrenheit: "+ str((c * 1.8) + 32)

Fahrenheit: 55.4
Fahrenheit: 69.8
Fahrenheit: 73.4
Fahrenheit: 46.4

>>> count = 5
>>> while (count > 0):
  print count
  count = count - 1

Python supports a number of useful built-in functions that do not require any external libraries to be imported. We have described a few of these functions as a collection of a respective category, according to their functionalities.

>>> a = 'a'
>>> int(a,base=16)
10
>>> i = 1
>>> str(i)
'1'

>>> list = [1.12, 2, 2.34, 4.78]
>>> min(list)
1.12
>>> max(list)
4.78

>>> pow(3.14159, 2)
9.869587728099999

In 2005, Massimo Banzi, the Italian cofounder of Arduino, developed the technology for his students at Interaction Design Institute Ivrea (IDII). Since then, Arduino has developed into one of the largest open source hardware platforms. All software components and schematics of the Arduino design are open source, and you can buy the hardware at a very low cost—approximately 30 dollars—or you can even make it yourself.

The major goal of the Arduino community is to continuously improve the Arduino platform with the following objectives in mind:

These simple but powerful objectives have made Arduino a popular and widely used prototyping platform. Arduino uses Atmel's ATmega series of microcontrollers that are based on the popular hardware architecture of AVR. The huge support that is available for AVR architecture also makes Arduino a hardware platform of choice. The following image shows the basic version of the Arduino board, which is called Arduino Uno (Uno means one in Italian):

Like any other project, hardware requirements are driven by project specifications. If you are developing a project that requires you to interface with a large number of external components, you need a prototyping platform that has a sufficient number of input/output (I/O) pins for interfacing. If you are working on a project that needs to perform a huge amount of complex calculations, you require a platform with more computation capability.

Fortunately, the Arduino board exists in 16 different official versions, and each version of Arduino differs from the others in terms of form factor, computational power, I/O pins, and other on-board features. Arduino Uno is the basic and most popular version, which is sufficient enough for simple DIY projects. For the majority of exercises in this book, we will be using the Arduino Uno board. You can also use another popular variant called Arduino Mega, which is a larger board with extra pins and a powerful microcontroller. The following table shows the comparison of some of the more popular and active variants of the Arduino board:

Any of these variants can be programmed using a common integrated development environment called Arduino IDE, which is described in the upcoming section. You can select any one of these Arduino boards according to your project requirements, and the Arduino IDE should be able to compile and download the program to the board.

As Uno is going to be the de facto board for the majority of the projects in this book, let's get ourselves familiar with the board. The latest revision of the Uno board is based on Atmel's ATmega328 microcontroller. The board extends the I/O pins of the microcontroller to the peripheral, which can then be utilized to interface components using wires. The board has a total of 20 pins to interface, out of which 14 are digital I/O pins and 6 are analog input pins. From the 14 digital I/O pins, 6 pins also support pulse-width modulation (PWM), which supports the controlled delivery of power to connected components.

The board operates on 5V. The maximum current rating of the digital I/O pins is 40 mA, which is sufficient to drive most of the DIY electronic components, excluding motors with high current requirements.

While the previous image provided an overview of the Uno board, the following diagram describes the pins on the Uno board. As you can see, the digital pins are located on one side of the board while the analog pins are on the opposite side. The board also has a couple of power pins that can be used to provide 5V and 3.3V of power to external components. The board contains ground pins on both sides of the board as well. We will be extensively using 5V of power and ground pins for our projects. Digital pins D0 and D1 support serial interfacing through the Tx (transmission) and Rx (receiver) interfaces respectively. The USB port on the board can be used to connect Arduino with a computer.

Now that we are familiar with the Arduino hardware, let's move on to programming the Arduino board.

The first step to start getting familiar with Arduino is to install the Arduino integrated development environment (IDE). According to the operating system that you selected at the beginning of the Python installation section, follow the appropriate subsection to install the correct IDE.

$ sudo apt-get update && sudo apt-get install arduino arduino-core

$ sudo yum install arduino

An Arduino program that is developed using the IDE is called a sketch. Sketches are coded in Arduino language, which is based on a custom version of C/C++. Once you are done with writing the code in the built-in text editor, you can save it using the.ino extension. When you save these sketch files, the IDE automatically creates a folder to store them. If you are using any other supporting files for a sketch, such as header files or library files, they are all stored at this location (which is also called a sketchbook).

To open a new sketchbook, open the Arduino IDE and select New from the File menu, as shown in the following screenshot:

You will be prompted with an empty text editor. The text editor supports standard features (that is, copy/paste, select, find/replace, and so on). Before we go ahead with an Arduino program, let's explore the other tools provided by the IDE.

The Arduino IDE uses libraries to extend the functionalities of existing sketches. Libraries are a set of functions combined to perform tasks around a specific component or concept. The majority of the built-in Arduino libraries provide methods to start working with external hardware components. You can import any library by navigating to Sketch | Import Library…, as shown in the following screenshot:

You can also use a library for your sketch by just specifying the library with the #include statement at the beginning of the sketch, that is, #include <Wire.h>.

The Arduino IDE also provides the capability to add an external library that supports a specific hardware or provides additional features. In the upcoming chapters, we will be dealing with some of these external libraries, and we will go through the process of importing them at that time.

You can learn more about built-in Arduino libraries from http://arduino.cc/en/Reference/Libraries.

The Arduino IDE contains a large number of built-in example sketches. These examples are designed to get the user familiar with basic Arduino concepts and built-in Arduino libraries. The examples are well maintained by the Arduino community since they have comprehensive support for each example through the Arduino website (http://arduino.cc/en/Tutorial/HomePage). In the Arduino IDE, you can access these examples by navigating to File | Examples, as shown in the following screenshot:

Let's start with a simple in-built example. Open the Blink example by navigating to File | Examples | 01.Basics | Blink. The IDE will open a new window containing code that is similar to the code in the following program:

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.

  This example code is in the public domain.
 */

// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;

// the setup routine runs once when you press reset:
void setup() {
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}

This Arduino sketch is designed to blink an LED on digital pin 13. You must be wondering why we didn't discuss or ask you to bring any hardware. That's because the Arduino Uno board is equipped with an on-board LED that is connected to digital pin 13. Now, instead of diving deeper into the Arduino code, we are going to focus on the process of dealing with the Arduino board through the IDE.

Once you have your code opened in the IDE, the first thing you need to do is to select the type of Arduino board on which you are going to upload your sketch. The Arduino IDE needs to know the type of board in order to compile the program for the appropriate microcontroller, as different Arduino boards can have different Atmel microcontrollers. Therefore, you need to perform this step before you go ahead with the compiling or uploading of the program to the board.

You can select the Arduino board by navigating to Tools | Board, as displayed in the following screenshot:

Select Arduino Uno from the list of boards, unless you are using a different Arduino board. Once you have selected the board, you can go ahead and compile the sketch. You can compile the sketch by navigating to Sketch | Verify / Compile from the menu bar or by using the keyboard shortcut Ctrl + R. If everything is set up well, you should be able to compile the code without any error.

After successfully compiling the sketch, it is time to upload the compiled code to the Arduino board. To do this, you need to make sure that your Arduino IDE is properly connected to your computer. If it is not already connected, connect your Arduino board to your computer using a USB port. Now, it is time to let your IDE know the serial port on which the board is connected. Navigate to Tools | Serial Ports and select the appropriate serial port.

$ sudo usermod -a -G uucp, dialout, lock <username>

You can now upload the compiled sketch to your Arduino board by navigating to File | Upload. This process will use the serial connection to burn the compiled firmware in the microcontroller. Please wait for some time or until the LEDs (Tx and Rx LEDs) on the board stop flashing. Now, you have your Arduino board ready with your first sketch. You can observe the performance of the blinking LED near digital pin 13.

In the previous process, we used a Universal Serial Bus (USB) cable to connect your Arduino board to a USB port of your computer. The USB port is an industrial standard to provide an interface for connecting various electronic components to a computer using the serial interface. When you connect an Arduino board using USB, the computer actually interfaces it as a serial peripheral device. Throughout the book, we are going to refer to the connections made using a USB as serial connections. The Serial Monitor window is a built-in utility of the Arduino IDE. The Serial Monitor window can be accessed by navigating to Tools | Serial Monitor or by using the Ctrl + Shift + M keyboard shortcut. It can be configured to observe data that is being sent or received on the serial port that is used to connect the Arduino board to the computer. You can also set the baud rate for the serial communication using the drop-down menu option. This utility is going to be very useful (further on in the book) when testing your prototypes and their performances.

Arduino follows a commenting format that is adopted from C and it is similar to higher-level languages; however, it is different from the Python comment format that we learned earlier in this chapter. There are various methods of commenting, which are as follows:

Usually, a block comment at the beginning of the sketch is mostly used to describe the program as a whole. Single-line comments are used to describe specific functions or to-do notes, such as the following one:

//TODO: explain variables next.

Like any other high-level language, a variable is used to store data with three components: a name, a value, and a type. For example, consider the following statement:

int pin = 10;

Here, pin is the variable name that is defined with the type int and holds the value 10. Later in the code, all occurrences of the pin variable will retrieve data from the declaration that we just made here. You can use any combination of alpha-numeric characters to select the variable name as long as the first character is not a number.

In the Arduino language, constants are predefined variables that are used to simplify the program:

We will utilize these constants later in the book and we will also explain them with example code.

The declaration of each custom variable requires the user to specify the data type that is associated with the variable. The Arduino language uses a standard set of data types that are used in the C language. A list of these data types and their descriptions are as follows:

Conversion functions are used to convert any data type value into the provided data types. The Arduino language implements the following conversion functions that can be utilized during programming:

As a demonstration of using these functions, check out the following example:

int myInt = 10;
float myfloat = float(myInt);

Implementation of the preceding code will create a floating-point variable, myFloat, with value 10.0 using the integer value initialized by the myInt variable.

Functions, also called subroutines or procedures, are a piece of code implemented to do specific tasks. The Arduino language has some predefined functions and the user can also write custom functions to implement certain program logic. These custom functions can then be called from any part of the sketch to perform a specific task. Functions help programmers to simplify debugging, to reduce chances for error, and to organize coding concepts:

void blinkLED(){
// action A;
// action B;
}

The Arduino language has a set of library functions to simplify the programming experience. Although not all of these library functions are required by an Arduino sketch, setup() and loop() are mandatory functions and they are required to successfully compile the sketch.

void setup() {
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);
}

void loop() {
  digitalWrite(led, HIGH);
  delay(1000);
  digitalWrite(led, LOW);
  delay(1000);
}

pinMode(led, OUTPUT)