The History of the Raspberry Pi

It may seem to some readers that the Raspberry Pi is new; there are a surprising number of people who have no idea what it is. Even now, seven years after the first Pi was produced, a large number of online articles begin with something along the lines of “The Raspberry Pi is a small, credit-card sized computer that hobbyists have begun using for . . .” This is in stark contrast to, say, the Arduino; most people who are up on current events have at least heard of it, even if they have no idea what it is or what it’s used for, since it’s been around since 2005 and has gained an immense, vocal following among hobbyists, geeks, and do-it-yourselfers around the world.

As I said, the Raspberry Pi has been around for a few years—seven, to be exact. There are several different models available, with a new, improved version being released about once every other year.

The Pi’s creators—Eben Upton, Rob Mullins, Jack Lang, and Alan Mycroft—first floated the idea of a cheap PC for teaching purposes in 2006. They were all based at the University of Cambridge in the United Kingdom, and they were concerned that the demise of cheap personal computers like the Commodore 64, the Amiga, and the Spectrum was adversely affecting young people’s ability to program. With desktop and laptop machines costing hundreds or thousands of dollars, kids and teenagers were forbidden to practice programming on the family’s main computer for fear of breaking it.

At the same time, Upton and the others realized that many university computer science curricula had been reduced to “Microsoft Word 101” and “How to Create a Web Page Using HTML.” The four creators wanted to raise the programming knowledge bar of incoming students, and thus perhaps computer science and engineering courses would become a bit more robust and applicable to STEM fields in the real world.

Obviously, a cheaper computer was necessary. They played around with microcontrollers and various chips, breadboards, and PCBs (see Figure 1-1), but it wasn’t until 2008 that the idea became more feasible. Chips were becoming smaller, cheaper, and more powerful, thanks to the explosion in mobile devices. These chips enabled them to plan a device that would be capable of supporting multimedia, not just command-line programming, which they felt was important in order to attract all ages of students. Young people were more likely to be interested in a media-capable device, and thus would be more likely to try programming on one.

In 2008, the original four creators, along with Pete Lomas and David Braben, formed the Raspberry Pi Foundation (the Foundation), and three years later the first mass-produced Pi rolled off the assembly line.

Within a year, the Foundation had sold over one million units. The founding members have spoken many times about how they were dumbfounded by the explosive interest in their device. Their original goal of putting a cheap, programmable device in the hands of educators and their students has come to fruition, but the Pi has also become much more than that. Apparently, they were not the only people who were missing the ability to program on a cheaper machine; hobbyists around the world (including yours truly) flooded element14, Premier Farnell, and RS Electronics with orders—to the point that people who had pre-ordered their Pi had to wait up to six months for supply to catch up with demand. (As of this writing, one of the latest models of the Pi, the Pi Zero W, is still only available on a one-per-customer basis.) Many customers may have been current or former programmers, eager to play with a new, small, powerful computer. I, for instance, first learned to program in BASIC on the Commodore VIC-20, a computer with an impressive 5KB of RAM.

Luckily, for the most part, supply has securely caught up with demand. There is no waiting period to buy a Pi anymore, and with the exception of the Zero W there is no longer a limit of one per customer. There are countless “hats” available (form-fitting aftermarket add-on boards with various capabilities), as well as a camera board and an official touchscreen display that both plug into the ports on the Pi. The founders have also actively encouraged other companies to copy their paradigm, and that has probably been largely responsible for the current number of small single-board computers available today.

Exploring the Pi

It is no longer possible to write just a single section that claims to exhaustively illustrate the Pi’s built-in parts and design, as there are many different designs available. I will, however, keep this section small by addressing only the three most recent releases: the Pi version 3, the Zero, and the Zero W. As it happens, the Zero and the Zero W have almost identical setups, so we need only describe one of the two. The price point of all of these boards has remained low; the version 3 is currently about $35US, the Zero is about $5, and the Zero W is $10. On March 14, 2018, also known as Pi Day, the Raspberry Pi Foundation released an update to the Pi version 3, the 3 B+. This newer version offers a few upgrades to the original version 3, including dual-band WiFi, a slightly faster CPU (1.4GHz), and power-over-Ethernet (PoE) capabilities. As this version is still very new, as its form factor is almost identical to the original version 3, and as its upgrades won’t affect any of the projects in this book, I won’t mention it beyond this point.

The size of the Pi hasn’t changed over the years; the Pi 3 measures the same as the Pi 1: 85.6mm x 56mm x 21mm. The Pi Zero and Zero W are a bit smaller: 30mm x 65mm x 3.5mm (not having USB and Ethernet ports makes a huge difference in thickness). The newest Pi is a bit heavier—45 grams versus the original’s 31 grams—but luckily weight probably doesn’t factor in when you’re trying to fit the new Pi into your old case or project design.

Take a look at Figure 1-2, and I’ll take you on a short clockwise tour of the board, starting with the GPIO pins.

Camera Connector

The camera connector on the board allows you to connect either the official Raspberry Pi camera board (Figure 1-3) or the NoIR (infrared) camera board to the Pi.

The Pi Zero/Zero W

That’s a fairly exhaustive look at the Pi 3’s setup, but no newer book would be complete without a look at the Pi’s newest little brothers, the Pi Zero and the Pi Zero W (Figure 1-4). The Pi Zero was introduced in November of 2015, followed by the Zero W a little later. The Zero W was basically the same model as the Zero, only with built-in wireless Internet.

Let’s take a quick look at everything the Zero W offers.

Comparing the Raspberry Pi to Similar Devices

You may ask, again, what makes the Pi superior to other small microcomputers like the Arduino and perhaps the Beagleboard line of devices? The answer is that the Pi isn’t necessarily better; each of these boards fills a particular niche, and it can be difficult to compare them, especially with microcontrollers like the Arduino. Arduinos are awesome for creating simple projects, and even for controlling a very simple robot, and in many cases using a Pi for such purposes would be overkill. As for the other microcomputers out there, one of the main differences is the price. A close relative to the Pi is the Beagleboard, but the suggested price for that board is over $75—much more than the Pi. And purchasing the Raspberry Pi means you’re supporting a charitable organization aiming to put cheap computers in the hands of schoolchildren worldwide, so there’s that, too.

Getting Started with the Pi

I think you’d agree that now is as good a time as any to take the Pi out of the box, if you haven’t already. Just read on before you start it up.

Hardware Requirements of the Pi

Let’s take a quick look at what the Pi’s requirements0 are, and then we’ll start it up. For the purposes of this chapter—indeed, most of the book—I’ll be assuming that you, the reader, are using the Pi 3 rather than the Zero. Most things will remain the same; if there are noticeable differences, such as in power requirements, for example, I’ll be sure to mention them.

Adding a USB Hub

You may want to add a USB hub at some point, though the Model 3 has four USB ports. If you’re using a Zero, you’ll definitely need one, at least at first. Performance can get a bit finicky when you add a hub because some USB hubs have been shown to work much better than others when it comes to working with the Pi. Perhaps the most important necessary feature is that the hub is externally powered; this will prevent your Pi from having to provide enough power to whatever power-sucking device you’ve decided to plug in that day. If you don’t have a spare hub floating around and are unsure of what to try, the Raspberry Pi forums are often a good place to start looking ( http://www.raspberrypi.org/phpBB3 ). It’s here that users like you have tried umpteen different brands and reported back about which ones work, which ones don’t, and which ones require a little tweaking. Luckily, hubs are relatively inexpensive, so if the first one you try doesn’t work, you can use it elsewhere and try a different one with your Pi.

The one I use with the Zero is a MakerSpot mini USB hub (Figure 1-5).

However, here is where you should do as I say, not as I do, because this particular hub is not externally powered. It does do everything I need it to without causing my Zero to suffer from brownouts (weird behavior due to insufficient power), so feel free to copy my success with it.

Now that you’ve outfitted your Pi with all of the necessary external parts, you’re ready to start setting it up.

The Pi Operating System

The Raspberry Pi’s default operating system (OS)—the one it’s designed to use—is Linux. The Pi 3 can run an IoT version of Windows 10, but setting it up can be a bit tricky, and in my experience the Pi just runs better with Linux. If you’re not familiar with the Linux operating system, don’t worry—we’ll peek under the hood in Chapter 2. For now, though, know that Linux comes in several flavors, or distributions: Ubuntu (one of the most popular), Debian, Mint, Red Hat, Fedora, and a few other more obscure varieties. The Pi uses a version of Debian called, appropriately enough, Raspbian.

Because the Pi doesn’t have a hard drive, you must download and copy a disk image to an SD card. That image is what the Pi will use to boot, and it will also act as memory/RAM. Almost any size card will do, as long as it’s at least 4GB, and more than 8GB is preferred if you plan on loading an appreciable amount of extra software onto the card (yes, you will end up doing just that). As I mentioned earlier, cards of up to 64GB have been shown to work just fine; beyond that, your results may vary. It’s recommended that you use a brand-name card, and it should be a class 4, which denotes the speed of the card.

Connecting the Peripherals

As a matter of fact, the most critical detail to remember here is to hook up the power last. You can probably fudge on the others, but power should always be last.

There’s no on/off switch; as soon as you plug in the power, LEDs on the board should start lighting up, and you should briefly see a rainbow screen on your monitor (Figure 1-6).

This screen is actually generated by the Pi’s firmware as it initializes the onboard GPU. The GPU draws four pixels on the screen and then embiggens them, resulting in the multicolor square. You should see it for only a brief moment, followed by a scrolling list of text as the Pi continues its boot process.

Configuring the Pi

When you start up the Pi for the first time using NOOBS, you’ll see a selection box with six choices: Archlinux, OpenELEC, Pidora, RISC OS, RaspBMC, and Raspbian (though those choices might have changed depending on when you’re reading this). Select Raspbian with your mouse and click the “Install OS” button at the top left of the window. Click “Yes” to confirm in the pop-up box that follows, and then wait while the image is written to your SD card. It might be worth watching because the progress window has a few tips you can read while you wait. If you just downloaded the Raspbian image, the Pi should boot automatically to the desktop (Figure 1-7).

Once your Pi has booted and you’re at the desktop, one of the first things you should probably visit is the Software Configuration Tool, also known as raspi-config . This can be reached by typing

in a terminal. (To start a terminal, click the Terminal icon in the menu bar.) This tool allows you to make changes to configurations, like expanding the filesystem, enabling SSH and the camera, and setting your Pi’s locale. This last, accessible from the Localisation Options submenu, is more important than you think, as the Pi’s default locale (and associated keyboard layout) is in the United Kingdom, which means that if you’re in the United States, you’ll be unpleasantly surprised the first time you press Shift > 2, expecting to get the “@” symbol, and are greeted instead with the double quotation mark (“).

To navigate around the raspi-config tool (Figure 1-8), select whichever option you’d like to change with the arrow keys and press Tab and then Enter to select your choice. Definitely enable the camera, since you’ll be using it later, as well as SSH access and VNC capabilities—all found within the Interfacing Options submenu. I would also enable I2C, SPI, and Serial, since they always come in handy and will be used later on. Play with all of the settings as you like, and remember that you can’t really break anything. If you brick your card and make it unusable, simply use the SDCard tool to reformat it and recopy the OS onto it so you can start fresh. Later, you may want to be more careful, but I’ll show you how to back up your card so you don’t lose any of your settings if you do something foolish.

When you’re done playing with raspi-config, select “Finish” and press Enter.

Your Pi is now up and running. Congratulations, give yourself a pat on the back! Enjoy, but don’t get too comfy. Your next task should be to make sure everything is up to date. Most Linux distributions release updates and upgrades regularly, and Raspbian is no different. There’s a good chance there have been several important upgrades to the software and possibly the kernel between the time the Pi Foundation made the NOOBS or Raspbian image available for download and today.

To update the Pi, make sure your Ethernet cable is plugged in and start a terminal (either click the terminal icon or press Ctrl–Alt–T.) At the prompt, type

You’ll see lines of text flow smoothly by as the Pi refreshes its software list. When it finishes, the “$” prompt will return. At this point, type

Again, lines of text should scroll past. If new software is ready to be downloaded, the Pi will ask you if you want to download and install it. Press Enter (the default option). When it finishes and returns you to the $ prompt, everything should be at the latest version. Depending on what was updated, you may be prompted to restart. Do so, and you’ll be up to date.

Shutting Down the Pi

Before we begin our Linux discussion, let’s discuss shutdown. As a matter of fact, shutting down the Pi is really unnecessary; it’s such a low-power device that designers just expect that you’ll leave it running. You can shut it down, though, and in the interest of saving a little money and perhaps your Pi, I suggest you shut it down when you’re done using it. Since there’s no “Off” switch, the Pi is actually designed to be powered off simply by unplugging it, and nothing bad is supposed to happen (assuming you’ve saved your work, aren’t in the middle of something, and so on). But just unplugging it makes many of us computer types cringe, so let me teach you the true, proper shutdown method. Open the terminal and at the prompt type

This takes the processor through the proper shutdown sequence, killing running processes, stopping threads, and so on. When it’s finished, it’s really safe to unplug the Pi.

If you want to reboot from the terminal, typing

will reboot the Pi.

Summary

You’ve now been introduced to the Pi, installed its operating system, and updated it to within an inch of its life. You’ve also been introduced to the raspi-config tool, and you have even played a bit with the command-line interface (CLI). It’s time to take an in-depth look at Linux.

Getting Started with Linux on the Pi

To interact with your Pi, you’re going to be doing a lot of work with the terminal—also called the command-line interface , or CLI. With your Raspberry Pi desktop up and running, double-click the terminal icon to start it. Because you’re already logged in, you won’t be asked for a username and password; rather, the prompt will show something like this:

This is the command-line interface (Figure 2-2). It tells you that you are the user “pi,” logged into the machine “raspberrypi,” in the home directory (“~” is the terminal’s shorthand for “home”).

If you were in a different directory, the prompt would display that directory, such as

Exercise: Navigating in the Linux File System

Let’s practice moving around Linux’s file system with the command line in the following introductory exercise. Start by opening a terminal prompt (command-line prompt) by double-clicking the terminal icon on the Pi desktop’s menu bar (which is shown in Figure 2-3).

When it opens, make sure you’re in the home directory by typing

cd ~

And then type

pwd

The terminal should print out

/home/pi

Now, make a directory by typing

mkdir mydirectory

and then, without entering it, make a subdirectory within it by typing

mkdir mydirectory/mysubdirectory

If you now type ls, you should see mydirectory listed as an available directory. You can now type

cd mydirectory/mysubdirectory

and you’ll be in your newly created subdirectory.

Let’s test the echo function. In the terminal, type

echo "Hello, world!"

The terminal should respond with

Hello, world!

True to its name, echo merely repeats the arguments you give it. However, you can “echo” something to other output formats as well; the default simply happens to be the screen. For instance, you can create a text file by using echo and the ‘>‘ operator. Type

echo "This is my first text file" > file.txt

If you then list the contents of your directory by typing ls, you’ll see file.txt listed. Type

cat file.txt

to see its contents, and you should see

This is my first text file

in the terminal. Go ahead and create another text file called file2.txt by typing

echo "This is another file" > file2.txt

Now, rename your first file to file1.txt by typing

mv file.txt file1.txt

If you now list the contents of the current directory, you’ll see file1.txt and file2.txt. You can cat each file to make sure they’re the ones you created.

Next, let’s copy file1.txt to the directory one level up in the folder structure. Type

cp file1.txt ../file1.txt

If you now list the contents of your home directory by typing

ls ../../

you’ll see that file2.txt is there, while it has disappeared from your current directory. Congratulations! You’ve now successfully accomplished the most common file operations in the Linux command line (or shell)!

Speaking of shells, Linux has several available in most distributions.

Text Editors

Unlike Windows and Mac, which have Notepad, Wordpad, and Textedit, Linux has several possibilities when it comes to text editors. There is a standard editor called gedit installed on most distributions. Not only is it rather lightweight, it is also not included on the Pi. The Pi’s built-in text editor, Leafpad, is decent. You may also find yourself getting comfortable with nano, another text editor that is pre-installed on the Pi and has a very intuitive interface. But if you do any serious programming work on the Pi, you may eventually want to upgrade to one of Linux’s two powerhouses: vi or emacs.

Both vi and emacs are not only powerful editors; they can be used as IDEs (Integrated Development Environments) as well, with keyword text coloring/syntax highlighting and word completion. Both are extensible and customizable; emacs, for instance, has over 2,000 built-in commands, while vi can be customized with its many ports and clones. In fact, one of vi’s clones, Vim (Vi Improved), is included with almost every Linux distribution and is the one I’ll discuss here because it is more of an IDE than its predecessor, vi. Emacs can be user-programmable with Lisp extensions, but is very similar to vi for every sense of aesthetic you may have.

There is, however, a sort of war going on between emacs and Vim. Linux and Unix users strongly prefer one or the other, and they will get surprisingly animated when discussing/arguing the pros and cons of each. As a conscientious writer, I will introduce you to both programs here, but as a die-hard emacs user, I will do my best to sway your choice away from the swill that is Vim. As we discuss programs and scripts throughout the book, I won’t mention how they’re written, merely what the end result looks like. You may even decide you like the Pi’s default text editor, which is perfectly all right as well.

Using Vim

As I said, Vim is a modal editor, meaning that you switch in and out of insert and normal modes. To start a test file, navigate to your desktop and type

vim testfile.txt

Rather than opening another window, Vim opens in the terminal, which can get confusing if you’re not used to it. You should be faced with a window not unlike the one shown in Figure 2-4.

Vim opens in normal mode, meaning that you cannot edit the file right away. To do so, you must enter insert mode by typing “i”. The word “INSERT” will appear at the bottom left—a handy way of reminding you whether you’re in insert or normal mode. When you’re done typing, press the Esc key to return to normal mode. In normal mode, you can move around the document with the arrow keys, just as you can in insert mode, but you can’t change or add anything until you type “i”. To save a file, make sure you’re in normal mode by pressing the Esc key at least once. Then, type “:w” (without the quotes) and press Enter. To save and exit at the same time, type “:x” (again, without quotes) and press Enter. Obviously, if you’re in insert mode when you type these characters, all you’ll succeed in doing is adding :w or :x to your document.

Vim takes a lot of getting used to, and many people have trouble adjusting to the two different modes of operation. If you decide you like it, there are many tutorials online to teach you to use it to its full potential.

Using emacs

Emacs (to me, at least) is a bit more intuitive than Vim, particularly when you’re first starting to use it. To start, open a terminal and navigate to where you want your test file, such as the desktop. Once there, type

emacs testfile.txt

Emacs will look for testfile.txt, open it if it exists, and create it and open it if it doesn’t. You’ll then be faced with a blank page like the one you see in Figure 2-5.

You can start typing immediately. Table 2-3 lists the most common commands in emacs.

Table 2-3

Common Commands in emacs

Command	Keystroke(s)
Open/New	Ctrl+x + Ctrl+f
Close	Ctrl+x + Ctrl+c
Save	Ctrl+x + Ctrl+s
Cut	Ctrl+w
Copy	Alt+w*
Paste	Ctrl+y
Jump to beginning of line	Ctrl+a
Jump to end of line	Ctrl+e
Start/end select	Ctrl+space

*The Alt key is defined on most keyboards as the Escape key

So, for instance, if you want to move a line of text, move your cursor to the beginning of the line. Press Ctrl and the space bar; the status text at the bottom left of the window will read “Mark activated.” Then, move your cursor to the end of the line with Ctrl and “e.” The status text will disappear. Now, cut the selected text by pressing Ctrl+w, move your cursor to where you want to paste it, and press Ctrl+y.

It does take some getting used to, so if you decide you like emacs, there are many tutorials online that can help you learn the keystrokes. Once you learn it, it can be very powerful, but always remember this: most if not all of these commands are accessible from the menu.

Using nano

As mentioned earlier, nano is probably the easiest of the three editors to use and get used to. To start a file in nano, simply type

nano testfile.txt

into your terminal, and you should be greeted by a screen like the one in Figure 2-6. As with the other two editors, if the specified file exists, nano will open it; otherwise, nano will create it for you.

As you can see, common commands are listed at the bottom, with the caret character (^) signifying the Ctrl key. To save a file, type Ctrl+X to exit. You’ll be asked if you want to save the file and under what name. In general, type “Y” and then hit Enter to save the file you’ve opened or created.

Default Text Editor

The Pi used to come with an editor called Leafpad , but now it’s just a full-featured but lightweight editor without a name, similar to Ubuntu’s gedit, the Mac’s TextEdit, or Windows’ TextPad. To open it, click the Raspberry icon at the top left of the Pi’s desktop and then select “Text Editor” (Figure 2-7).

As you’ll see, it looks like most editors you’re used to. If you’re comfortable using it, please do. I don’t mention it much because its one main drawback is that it’s only usable if you’re working on the Pi’s graphic desktop. If you’re remotely logged into the Pi and are working solely through the command line, the text editor is inaccessible.

Summary

This concludes your introduction to Linux. While it in no way makes you an expert, it should give you a healthy appreciation for all that this powerful OS can do. You learned the basics of how to navigate through your file system using only the command line, and you were introduced to the shell. You’ve also been introduced to the text editors available to you and have hopefully chosen one that you are comfortable with. Once you’ve muddled around with it on your Pi enough, you may find yourself installing Linux on one or more of your other machines. It’s okay—I won’t tell anybody.

In the next chapter, I’ll do my best to give you a solid introduction to Python.

Scripting Versus a Programming Language

Python is a scripting language. Some may quibble over whether it’s a programming language or a scripting language, but to keep the strict technocrats happy, we’ll call it a scripting language.

The Python Philosophy

In the world of scripting languages, Python is a relative newcomer to the scene, though it is not as new as many people believe. It was developed in the late 1980s, perhaps 15 years after the conception of Unix.

It was implemented in December 1989 by its principal author, Guido Van Rossum. He has remained active in Python’s development and progress, and his contributions to the language have been rewarded by the Python community, which gifted him with the title Benevolent Dictator for Life (BDFL ).

In addition to these commandments, Python has a “batteries included” mindset, which means that whatever strange task you need to do in Python, chances are good that a module already exists to do just that, so you don’t have to reinvent the wheel.

Getting Started with Python

Let’s get started. There are three ways to run Python on your Pi: using the built-in interpreter IDLE, in a terminal window, or as a script. We’ll begin by using IDLE.

Running Python Using IDLE

The IDLE interpreter is a sort of “sandbox” where you can work with Python interactively without having to write whole scripts to see what they do. The name IDLE stands for “Integrated DeveLopment Environment,” but it also pays homage to Eric Idle, one of the founding members of the British comedy group Monty Python. (See the sidebar “Get Me a Shrubbery!”)

Because it’s the most user-friendly way of trying out code, let’s use IDLE first. You can find it by clicking the Raspberry icon at the top left of the menu bar and then opening the Programming submenu (see Figure 3-1). Select the Python 2 (IDLE) option, as we’ll be doing all of our Python programming in Python 2 (see the sidebar). You should be greeted by a window like that shown in Figure 3-2.

To follow the great programming tradition, let’s start with the first program a programmer ever writes in any language. At the prompt, type

>>> print "Hello, world!"

and press Enter. You should immediately be greeted with

Hello, world!

This is Python’s print statement, whose default option is to the screen. Now type

>>> x=4

and press Enter. The prompt will return, but nothing happens. What has actually happened is that Python’s interpreter has now associated x with 4. If you now type

>>> x

you’ll be greeted with

4

Likewise, if you type

>>> print x

you’ll again be greeted with

4

This illustrates another cool aspect of Python: dynamic typing. In languages like C, you must define a variable’s type before you declare it, like this:

string x = "This is a string.";

or

int x = 5;

Note

See the “Strings” section later in this chapter for more information on strings.

Python “knows” that x is an int (integer) when you tell it that x = 4.

Despite being dynamically typed, Python is strongly typed. This means it will throw an error rather than allow you to do things like add an int to a string. You can also define your own types using classes; Python fully supports object-oriented programming (OOP). I’ll touch on that later, but in short it means you can create an object that may be a mix of integers, strings, and other types, and that object will be its own type. Python has several built-in data types: numbers, strings, lists, dictionaries, tuples, files, and a few others (like Booleans). We’ll visit each of these briefly later in the chapter.

Moving forward, let’s try playing with some variables and operations inside of IDLE. Typing

>>> print x+5

will return 9; however, typing

>>> x + "dad"

results in an error. In this vein, however, typing

>>> "DAD" + "hello"

gives you

'Dadhello'

because, to Python, adding strings is the same as concatenating them. If you’d like to make a list, enclose it in square brackets:

>>> y = ['rest', 1234, 'sleep']

Also, a dictionary—a type of file made up of associated keys and key values—must be enclosed in curly braces:

>>> z = {'food' : 'spam', 'taste' : 'yum'}

Note

Keys and key values are an integral part of Python dictionaries. They’re just linked pairs of values. For example, in the z dictionary in the preceding code example, 'food' and 'spam' are a key and a key value, respectively. Likewise, 'taste' and 'yum' are a key and a key value. To use a dictionary, you input its key, and the associated key value is returned.

Get Me a Shrubbery!

Python is not named after the snake; rather, its creator, van Rossum, named it after the BBC comedy troupe Monty Python, of whom he is a huge fan. As a result, Monty Python references abound in the language. The traditional “foo” and “bar” used to illustrate code in other programs become “spam” and “eggs” in Python examples. You’ll see references to “Brian,” “ni,” and “shrubbery,” all of which should make perfect sense to you if you are a fan of Monty Python. Even the interpreter, IDLE, is named after M.P. member Eric Idle. If you are not familiar with their work, I urge you to put down this book and go watch some of their sketches. I heartily recommend “The Dead Parrot Sketch” and “The Ministry of Silly Walks.” It’s not necessary to be familiar with their work to learn the language, but it may help increase your enjoyment of it.

Python 2 Versus Python 3

Python is somewhat unique among programming languages in that there are two current, working, supported versions: version 2 and version 3. The former is at version 2.7.14 and Python 3 is currently at version 3.6.4. Python 3 was released in 2008; 2.7 was released in 2010 and will see no more major releases (i.e., there will be no version 2.8). Python’s creator decided to “clean up” the language with version 3, with less regard for backward compatibility than you would expect.

The most drastic improvement is how Python 3 handles Unicode, and several aspects of the language have been made to be more user friendly for beginners. Unfortunately, because there is limited backward compatibility, there is a lot of Python software written in Python 2 that simply won’t run in Python 3 without some serious overhaul that, quite frankly, is just not very tempting to do, especially since Python 2 is still supported.

My advice, such as it is, is to concentrate on learning Python 2, since 3 is not that much different. In this book, I'll be using Python 2, but feel free to translate into Python 3 if you feel the urge.

Running Python Using Scripts

The problem with both IDLE and the terminal is that you can’t write true scripts. As soon as you close the window, any variables you’ve declared disappear, and there’s no way to save your work. The last method of writing Python, in a text editor, addresses that problem. You can write a full-length program, save it with a .py extension, and then run it from a terminal.

Let’s write a very short script using the Pi’s default text editor. Open it from the Accessories menu (Figure 3-3).

In the resulting window, type the following:

x = 4

y = x + 2

print y

Save it to your desktop as test.py. Now, open a terminal and navigate to your desktop by typing

cd ~/Desktop

You can now run your script by typing

python test.py

You should be greeted with the number 6. Congratulations! You’ve just written, saved, and run your first Python script!

When you write the scripts in this book, feel free to use any text editor you wish. If you’re comfortable using the default text editor, by all means use it. I tend to use nano or emacs, the terminal-based editors, because I often log in to my Pi remotely, and the default editor can’t be run in a remote login session. For that reason, I’ll often tell you to edit a file like so:

sudo nano spam-and-eggs.py

Use whichever editor you wish.

Next, let’s look at each data type briefly and see what you can do with each.

Exploring Python Data Types

As mentioned earlier, Python provides you with several built-in data types. In the following sections, you’ll learn about numbers, strings, lists, dictionaries, tuples, and files.

Programming with Python

Now that you’ve seen the data types, let’s investigate how to use them in actual programs. To create a Python program, you must exit the interpreter and open a text editor, such as emacs or the Pi’s Leafpad. After you create the program, save it with a .py extension. You’ll then be able to run it by typing

Python is unique among programming languages in its syntax in that it blocks out code using whitespace or indentation blocks. Languages like C enclose a block of code such as an if statement within curly braces; Python uses a colon and indentation to delineate the block.

Code in C looks like this:

The same code in Python looks like this:

You may notice two additional details about the Python program. First, the parentheses in the if statement are not necessary. In Python, parentheses are optional, but in most cases it’s considered good programming practice to use them, as it enhances your code’s readability. You’ll also notice that most other languages end their lines of code with a semicolon; Python does not. This may take some getting used to, but it is a nice change to not have a program fail to compile because you’ve got a misplaced or missing semicolon somewhere in it. In Python, the end of the line is the end of the statement—that simple.

You’ve seen statements already, such as

As mentioned earlier, Python doesn’t require declarations telling it that x is an integer and y is a string—it just knows. These statements are known as assignments, where the value on the right is assigned to the variable on the left. There are various variable-naming conventions in different languages, but the best advice I can give you is to just pick a convention and stick with it. If you prefer Pascal case (ThisIsAVariable), use it; if you prefer camelback (thisIsAVariable), use that one. Just be consistent—you’ll thank yourself later. In any case, an assignment does just that: assigns a value to a variable, whether that variable is a number, string, list, or something else. It’s the simplest of the programming functions.

Summary

In this chapter, I gave you a brief but practical introduction to Python, starting with a little of its history and then continuing with how to interact with the Python prompt, helping you learn some of its data types, and then showing you a little bit of script writing using an editor. Don’t worry if you can’t take all this information in at once. There’s a lot to learn here, and I’ll explain what I’m doing as we progress through the projects in the book. In the meantime, there are literally thousands of books and courses available on Python, so if you want to learn more, feel free to dig around the Web and your local bookstore.

In the next chapter, we’ll take a look at Electronics 101. You’re going to be building projects, after all, and before you do, you should have a basic grasp of the concepts of electricity, power, and various electronic parts and gizmos.

Basic Electricity Concepts

The other important variable in a circuit is power, signified by P and measured in watts. Power is equal to voltage times current, voltage squared divided by resistance, or current squared times resistance. If this is confusing, use the diagram in Figure 4-2 to better envision the relationships.

As an example, a common way of illustrating the different electrical concepts is with water and different sized pipes. In a “water circuit,” the water power is provided by a pump. In an electrical circuit, the power is provided by a battery. In a water circuit, the pump takes water at low pressure, increases the pressure, and sends the water on its way around the circuit. In an electrical circuit, the battery takes “low-pressure” voltage, increases its volts, and sends it on its way around the circuit. In both cases, the current means the flow—of either electrons or water—around the circuit. The resistance of the circuit is analogous to how large the water pipe is. If the pipe is large, it offers less resistance to the water flowing through it. In a circuit, if the wire has less resistance it allows the electrons to flow more freely. This, in turn, affects the power.

Power increases with resistance and current. Think of power as the “speed” of the electricity; if you have a certain amount of water flowing from the end of a hose and you hold your finger over the end, increasing the resistance, the speed of the water increases. Increasing the resistance of the circuit increases the power. There are byproducts to this, of course. Partially blocking the end of a hose increases the friction at the mouth of the hose, and thus the heat. Likewise, increasing the resistance of a circuit often means increased heat. Heat is bad for circuits, especially fragile items like integrated circuits (ICs), so many electronic components that produce heat (because of internal resistance, among other reasons) often have a heat sink built in to dissipate the heat they create.

At its most fundamental, electricity is nothing more than electrons moving back and forth along a wire or some other path. That path is always the path of least resistance. Given the choice of two ways to travel, electrons will always take the easiest path, whether it’s through a wire, a screwdriver, or a human torso. Your goal, when working with these electrons, is to ensure that the easiest path does not involve your body. You won’t always be successful; I’ve been shocked more times than I can count. (In fact, in addition to the multiple electric shocks I’ve experienced with batteries and power supplies, I’ve actually been struck by lightning three times.) A conscientious experimenter should try to reduce these incidents, if for no other reason than that they can hurt! Rubber gloves can help (though wearing them all the time is a bit impractical), as can rubber boots or rubber-soled shoes. The reason rubber boots are a good idea, in addition to their being extremely fashionable, is that electrons always want to connect to ground. That “ground” may be a power ground, like the terminal of a battery; a chassis ground, like an engine block in a car; or the actual ground, called an earth ground . A rubber barrier between yourself and the ground discourages those electrons from making the journey through your body.

With the electricity basics under your belt, let’s talk about the tools you’ll need to build your projects.

Required Tools for Robotics

All engineers need good tools, and as a budding hobbyist/experimenter/engineer, you’re no exception. That dented, banged-up screwdriver sitting in your kitchen’s junk drawer may be fine for prying staples out of the wall, but if you try to use it for any delicate work on your projects, you’re just asking for trouble. Likewise, a pair of wire cutters with huge gaps in the teeth won’t do you any good when you’re trying to reach inside a tiny opening to clip the red wire before the timer reaches zero. To build cool things, you need good tools. The following sections will describe the necessary tools you should have.

Pliers and Wire Strippers

Again, spend the money on good pliers and wire strippers because you get what you pay for. You will definitely need a good pair of needle-nosed pliers (shown in Figure 4-3) that can be used as tweezers or to bend parts to fit.

You can probably get away without a regular pair of pliers, though I wouldn’t recommend it. Take good care of your pliers, and they’ll take good care of you. It’s difficult to bend wire or cut contacts with a pair of pliers that has gaps or doesn’t close correctly.

You’ll also need some wire strippers. Yes, you can use the cutters attached to your pliers to carefully score wire insulation and strip it, but when you have to do that repeatedly every time you need a wire end, it gets tedious really fast. Get some wire strippers and save yourself the headache. Either the kind shown in Figure 4-4 or the kind shown in Figure 4-5 will work—just be sure you know how to use them.

I actually use both because, although I appreciate being able to choose my wire size in the pair shown in Figure 4-4, I often come across odd-sized wire that doesn’t fit in any of that model’s pre-sized holes. That’s where the strippers shown in Figure 4-5 come into play. These are much faster to use, and if you’re stripping a lot of wires at once you’ll appreciate the speed and convenience.

Wire Cutters

You’ll need two types of cutters: regular cutters (Figure 4-6) and fine cutters (Figure 4-7).

The regular-sized cutters are great for everyday work, but the smaller cutters are invaluable when you have to snip tiny, broken solder joints or the frayed ends of #24-gauge wire.

Magnifying Light

You’ll be working with lots of very small objects, from resistors to wires to servo connections, and your eyes will get tired quickly. A good adjustable desk lamp with a magnifier built in is an incredibly valuable investment. The one I use is designed for use by jewelers and beaders, and the difference it makes when I’m trying to work with miniature pieces cannot be overstated. (See Figure 4-8.)

Multimeter

A multimeter measures different aspects of an electrical circuit—voltage across certain points, current, and resistance (see Figure 4-9). Whether you get an analog or a digital version is up to you, but be prepared to spend a little money, because a good multimeter is an incredibly valuable tool. It can be used to trace electrical shorts, ensure that you’re using the correct voltage, and figure out how much resistance exists between two points in a circuit.

When choosing your multimeter, make sure it can measure both AC and DC voltage levels as it’s likely you’ll be using both at some point. It should be able to measure resistance and continuity as well as current. The meters that give off a sound when two points are connected are very helpful when you’re trying to trace wires or a short in a system. The most important characteristic to look for, however, is ease of use. If you don’t know how to use the multimeter, you won’t use it, and you’d be wasting an important tool. So, get one you like that makes sense to you and then spend some time with the manual learning how to use it.

Power Supplies

When it comes to powering your experiments and projects, there are a few different routes you can take. Obviously, you’ll often be using batteries or battery packs, and I’ll talk about those for each specific project. However, when it comes to powering a prototype or just determining if a particular configuration works, you can’t go wrong with a wall wart—the AC-to-DC converters that come with almost all electronic devices these days.

You can get an adjustable wall wart at an electronics store, which I recommend, but you can also haunt your local thrift store. Somewhere, buried in the back by the electronics, you may find a bin full of abandoned power supplies for around a dollar apiece. You can either cut off the connector so you can plug it directly into your breadboard or get an adapter like the one in Figure 4-10.

I tend to pick up power supplies whenever I see them, or keep them when I throw a device away at home, so I have a pretty good assortment. Try to find at least a 9V and a 12V, with different current ratings, because these are common voltage sources. If your device runs well with your 12V source, for example, that means it’ll probably run well in your car. If you happen across an uncommon power supply, such as an AC-to-AC transformer, definitely keep it—it might come in handy!

Breadboard

A breadboard is another must-have when you’re putting electronics together to see if everything works as it should, before you start soldering and making everything permanent. You can go full out, with a deluxe model with power connections and meters and all sorts of bells and whistles (as shown in Figure 4-11).

Or you can go with a more old-school version, like the one shown in Figure 4-12.

Either way, just be sure you can plug devices like resistors and ICs into it and that you can connect those devices using jumper wires. And, as your skills increase and your interests diversify, be prepared for your breadboard to someday look like the image in Figure 4-13.

Yes, you’ll be debugging that conglomeration of wires, and no, I can’t help you. But I feel for you—I truly do.

Soldering Iron

Another critical tool on your list should be a soldering iron, and this is the one item you shouldn’t skimp on when it comes to cost. The $9.99 iron you can get at your local department store might be all right for tinkering with some circuits around the house, but when you’re a serious builder/hobbyist, you need a good-quality, adjustable soldering iron. I have a Weller WES51 (shown in Figure 4-14).

It’s easily the best $100 I ever spent in my electronics career. Get one with a stand, adjustable heat, and tips you can swap. Trust me: your projects will thank you when you can use the correct temperature to make the solder melt without melting your circuit, or when you can use even heat to remove a bad solder joint.

While you’re shopping for the iron, get a few soldering accessories as well. A solder-sucker (a hand-held vacuum pump that removes melted solder from joints) is a must-have, as is a helping-hands tool (see Figure 4-15).

A helping-hands tool comes in very handy when you need two hands to hold a connection and another two hands to solder that connection and you’ve burned your wife’s fingers one too many times and your kid is nowhere to be found. You can even make your own out of stiff baling wire, alligator clips, and a wooden stand.

General Safety Rules

Here is where I get to act like your mother and ask if you’re being safe. After all, although we’re building relatively innocuous projects in this book, you’re still dealing with some components that can seriously hurt you. The tip of your soldering iron, for instance, averages around 450°F. Hot glue, even the low-temp variety, melts at about 250°F. Sure, programming is a fairly harmless activity, but you’ll also be cutting, drilling, sanding, and doing any number of other tasks that have the capability to badly injure you. So, please take this safety talk seriously.

Organizing Your Workplace

As you progress in your experimenting endeavors by buying additional tools, parts, chips, boards, and so forth, you’re going to need a way to organize it all. Keeping your work area organized could just as easily fall under safety, since having everything stored neatly in its place can eliminate workplace hazards as well.

At the very least, buy several sizes of sandwich baggies so that you can keep different parts separated, but when you pass the point of no return, look into storage solutions. I have had good luck in the beading section of my local craft store, since many electronics parts are about the size of beads. One of my storage areas looks like the image in Figure 4-16, while another one looks like that in Figure 4-17.

Notice the labels; buy yourself a label maker! Easily another of my best purchases—you can label drawers, power supplies, cords, the children . . . the possibilities are endless. Also, once you get going and have more than one project in progress at a time, you may find it easier to separate by project rather than by part, at least some of the time. Some things, like switches, are used everywhere, but I know that when it’s time to attack my time fountain again or do some more light painting, I can find all of the parts I’ve been working with in those respective boxes.

I must add here that when it comes to organizing a shop, especially where tools are concerned, check out Adam Savage’s Tested series on YouTube. There are many videos where he explains how he organizes his tools and how he builds—if necessary—the containers in which he stores his equipment. It’s inspiring and bound to give you a lot of ideas, even if you’re only using a small corner in the back of your kitchen.

In general, just keep your area clean. Not only is it much more efficient to find things when they’re where they’re supposed to be, but tripping over a power-supply cord when holding an X-ACTO knife can be a dangerous incident. Get your tool or part from its place, use it, and then put it back. (This is another area where you may have to do as I say, not as I do. You’ll be seeing pics of my workspace throughout the book, and I can’t guarantee it’ll always be the neatest space. I tend to spread out when I work. But you get the idea.)

Bonus: Soldering Techniques

In this last section of this introductory electronics chapter, I’ll give you a few tips on how to solder. Soldering is an art as much as a skill, and it does take practice. If you’ve never soldered before, your first joints are bound to be lumpy, ugly clumps, but improvement can be swift if you stick with it. No more than a few hours spent soldering components together for practice can make a huge difference when you do it for a real project.

The last step is probably the most important. The tip of your iron should be clean; get in the habit of wiping it on a damp sponge whenever you finish a joint and before you start another one. A clean tip will transfer heat better. You should also heat the joint, not the solder. Don’t melt the solder onto the tip of the iron and then smear it onto the connection—you’ll run the chance of making a cold solder joint (shown in Figure 4-18), which is bound to fail eventually. Remember: heat the parts, not the solder. If you have trouble getting the joint hot enough for the solder to melt onto it, you can melt a tiny bit of solder onto the tip of your iron before touching a joint, since the solder will transfer the heat more effectively. You should end up with a joint that looks like the one in Figure 4-19.

Again, don’t stress too much about your soldering skills or lack thereof. With a little practice you’ll be soldering circuits like an expert.

Aside from just doing it, perhaps the best way to learn to solder well is to watch it, and the magic of YouTube now makes that possible. A quick search for “how to solder” brings up over 300,000 results. I can’t pick any two or three that stand out, but if you watch a few you should get the idea. Makezine, an incredibly informative online blog, has a good page with resources on learning how to solder. It’s located at http://makezine.com/2006/04/10/how-to-solder-resources/ .

Summary

After being introduced to some basic electricity principles, you learned your way around some of the common electronics tools in the lab and learned the basics of how to use them safely. I also introduced you to soldering and pointed you in the direction of some resources that can help you learn to do it better.

Let’s gather our tools and head into the projects, starting with a simple one that doesn’t require any tools—the WebBot.

Bot Etiquette

One factor you need to keep in mind, should you build a functioning web crawler, is bot etiquette. I don’t mean etiquette in the sense of making sure that the bot’s pinky is extended when drinking high tea. Rather, there are certain niceties you should observe when you program your bot to crawl sites.

One is to respect the robots.txt file. Most sites have this file in the root directory of the site. It’s a simple text file that contains instructions for visiting bots and spiders. If the owner of the site does not want certain pages crawled and indexed, he can list those pages and directories in the text file, and courteous bots will accede to his requests. The file format is simple. It looks like this:

This robots.txt file specifies that no bots (User-agent: *) may visit (crawl) any pages in the /examples/ folder, nor may they visit the page private.html. The robots.txt file is a standard mechanism by which websites can restrict visits to certain pages. If you want your bot to be welcome at all sites, it’s a good idea to follow those rules. I’ll explain how to do that. If you choose to ignore those rules, you can often expect your bot (and all visits from your IP address) to be banned (and blocked) from the site in question.

Another piece of etiquette is controlling the speed of your bot’s information requests. Because bots are computers, they can visit and download pages and files hundreds and thousands of times faster than humans can. For this reason, it is entirely possible for a bot to make so many requests to a site in such a short time that it can incapacitate a poorly configured web server. Therefore, it is polite to keep your bot’s page requests to a manageable level; most site owners are fine with around ten page requests per second—far more than can be done by hand, but not enough to bring down a server. Again, in Python, this can be done with a simple sleep() function.

Finally, it can often be problematic to fake your user-agent identity. A user-agent identity identifies visitors to a site. Firefox browsers have a certain user agent, Internet Explorer has another, and bots have yet another. Because there are many sites that do not want bots to visit or crawl their pages at all, some bot-writers give their bots a fraudulent user agent to make it look like a normal web browser. This is not cool. You may never be discovered, but it’s a matter of common decency—if you had pages you wanted kept private, you’d want others to respect those wishes as well. Do the same for other site owners. It’s just part of being a good bot-writer and netizen (net citizen). You may simulate a browser’s user agent if you are emulating a browser for other purposes, such as site testing or to find and download files (PDFs, mp3s, and so on), but not to crawl those sites.

The Connections of the Web

Before we get to the business of programming our spider, you need to understand a bit about how the Internet operates. Yes, it’s basically a giant computer network, but that network follows certain rules and uses certain protocols, and we need to utilize those protocols in order to do anything on the Web, including using a spider.

Our Web Bot Concept

The concept behind our web bot is as follows: we’ll start with a certain page based on user input. Then, we’ll determine what files we are looking for—for example, are we looking for .pdf files of works in the public domain? How about freely available .mp3s by our favorite bands? That choice will be programmed into our bot as well.

The bot will then start at the beginning page and parse all of the text on the page. It will look for text contained within <a href></a> tags (hyperlinks). If that hyperlink ends in a “.pdf” or “.mp3” or another chosen file type, we’ll make a call to wget (a command-line downloading tool) to download the file to our local directory. If we can’t find any links to our chosen file type, we’ll start following the links that we do find, repeating the process for each of those links as recursively as we determine beforehand. When we’ve gone as far as we want to, we should have a directory full of files to be perused at our leisure. That is what a web bot is for—letting the computer do the busy work, while you sip a margarita and wait to enjoy the fruits of its labor.

Parsing Web Pages

Parsing refers to the process a computer goes through when it “reads” a web page. At its most basic, a web page is nothing more than a data stream consisting of bits and bytes (a byte is eight bits) that, when decoded, form numbers, letters, and symbols. A good parsing program not only can re-form that data stream into the correct symbols, but it can also read the re-formed stream and “understand” what it reads. A web bot needs to be able to parse the pages it loads because those pages may/should contain links to the information it’s programmed to retrieve. Python has several different text-parser modules available, and I encourage you to experiment, but the one I have found the most useful is Beautiful Soup.

Beautiful Soup (the Python library) has gone through several versions; as of this writing, it is on version 4.6.0 and works in both Python 2.x and 3.x.

Beautiful Soup’s syntax is pretty basic. Once you’ve installed it by typing

in your terminal, you can start using it in your scripts. Open a Python prompt by typing python and try typing the following:

If you get an error message that says No module named BeautifulSoup, you may be using an older version of Beautiful Soup 4. In that case, type

Then, continuing in your Python prompt:

This loads the file named doc with what a web-page stream would look like—a long, single stream of characters. Then, Soup loads the lines into a file that can be parsed by the library. If you were to type print soup at this point, it would look the same as the results of typing print doc.

However, if you type

you’ll be rewarded with the page, redone in a more readable fashion. This is just an example of what Beautiful Soup can do; I’ll go over it more when we get to programming the bot.

As an aside: the re module you import in the preceding example is used to evaluate regular expressions in text. Regular expressions, if you’re not familiar with them, are an extremely versatile way to search through text and pick out strings and sequences of characters in ways that may not be immediately obvious to a human reader. A regular expression term can look like complete gibberish; a good example of a regular expression is the sequence (?<=-)\w+, which searches for a sequence of characters in a string that follows a hyphen. To try it out, open a Python prompt by typing python and then type

and you’ll be rewarded with

While regular expressions are very helpful in terms of finding sequences of characters in text and strings, they’re also not very intuitive and are far beyond the scope of this book. We won’t be spending much time on them here. It’s enough that you know they exist, and you can spend some time learning about them if they interest you.

Coding with Python Modules

When it comes to using different Python modules to code your web spider, you have quite a few options. Many open-source spiders already exist, and you could borrow from those, but it’s a good learning experience to code the spider from the ground up.

Luckily, most of these are pretty simple tasks, so programming our spider should be relatively straightforward.

Deciding What to Download

This can get kind of sticky because there is so much out there. Unfortunately (or fortunately, depending on your point of view), a good deal of it is copyrighted, so even if you find it for free, it’s really not cool to just download it. Whatever you’re looking for is out there.

That, however, is a topic for an entirely different book. For the time being, let’s assume you’re going to be looking for freely-available information, such as all works by Mark Twain that are in the public domain. That means you’re probably going to be looking for .pdf, .txt, and possibly even .doc or .docx files. You might even want to widen your search parameters to include .mobi (Kindle) and .epub files, as well as .chm. (chm stands for Compiled HtMl, which is used by Microsoft in their HTML-formatted help programs, and it is also often used in web-based versions of textbooks.) These are all legitimate file formats that may contain the text of books you’re looking for.

Storing Your Files

You may also need a place to store your files, depending on the size of your Pi’s SD card. That card acts as both RAM and a place for file storage, so if you’re using a 32GB card, you’ll have lots of room for .pdf files. However, an 8GB card may fill up rather quickly if you’re downloading free documentary movie files. So, you’ll need an external USB hard drive—either a full-blown hard drive or a smaller flash drive.

Again, this is where some experimentation may come in handy, because some external drives won’t work well with the Raspberry Pi. Because they’re not particularly expensive these days, I would buy one or two medium-sized ones and give them a try. I’m currently using an 8GB flash drive by DANE-ELEC (shown in Figure 5-2) without any problems.

A note on accessing your jump drive via the command line: a connected drive such as a flash drive is accessible in the /media directory; that is,

cd /media

will get you to the directory where you should see your drive listed. You can then navigate into it and access its contents. You’ll want to set up your Python script to save files to that directory—/media/PENDRIVE, for example, or /media/EnglebertHumperdinckLoveSongs. Probably the easiest way to do it is to save your webbot.py script in a directory on your external drive and then run it from there.

Writing the Python Bot

Let’s start writing some Python. The following code imports the necessary modules and uses Python’s version of input (raw_input) to get a starting point (to which I’ve prepended the http:// found in every web address). It then initiates a “browser” (with air quotes) with mechanize.Browser() . This code, in its final completed form, is listed at the end of this chapter. It’s also available for download as webbot.py from the apress.com website.

To start the process of writing your bot, use your text editor to begin a new file, called webbot.py. Enter the following:

Later, we may need to fake a user agent, depending on the sites we visit, but this code will work for now.

The Final Code

Here, you can see the final, lengthy code you’ve been typing in, bit by bit, if you’ve been following along as we progressed through the chapter. Again, if you don’t want to type it all, it’s available on Apress.com as webbot.py. However, I highly recommend you type it in, because learning code can be much more effective if you type it rather than simply copying and pasting it. One of my professors used to say that by typing it in, you make the code your own.

Summary

In this chapter, you got a nice introduction to Python by writing a web bot, or spider, that can traverse the Internet for you and download files you find interesting, perhaps even while you sleep. You used a function or two, constructed and added to a list object, and even did some simple string manipulation.

In the next chapter, we’ll transition away from the digital world and interact with a very physical phenomenon—the weather.

A Shopping List of Parts

Using the I2C Protocol

This project takes advantage of the I2C protocol for communicating with the humidity and pressure sensors that you’ll add to the Pi. While it’s a relatively simple protocol, it can get a little confusing, so it’s best to review it quickly before we start building the station.

I2C enables a large number of devices to communicate on one circuit using only three wires: a data line, a clock line, and a ground wire. Each device is called a node, and there is usually one master node and many slaves. Each slave node has a 7-bit address, such as 0x77 or 0x43. When the master node needs to communicate with a particular slave, it begins by transmitting a “start” bit, followed by the slave’s address, on the data line. That slave responds with an acknowledgment, while all other slaves ignore the rest of the message and go back to waiting for the next address pulse to be transmitted. The master and slave then communicate with each other, often switching between transmitting and receiving modes until all information has been transmitted.

I2C has been referred to as “the serial protocol on steroids,” and it is most often used in applications where speed does not matter and the cost of parts needs to remain low. The Raspberry Pi has two pins, #3 and #5, that are preconfigured to be the I2C protocol’s SDA (data) and SCL (clock) lines, respectively, so it can easily communicate with I2C devices. Two of the devices we’ll be using (the barometer/altimeter and the magnetometer) are I2C devices.

The Pi also has an I2C utility that makes it possible to see the devices that are currently connected. To install it, type

If you’re using a recent version of Raspbian, such as Wheezy or Stretch, these should be installed already, in which case you’ll just get a note telling you that they’re already the newest version.

Now, you can run the I2C utility tool called i2cdetect to make sure everything is working and see what devices are connected. Type

which should display the screen shown in Figure 6-2.

In this case, no devices are present, which makes sense because we haven’t plugged any in yet. But you now know that your tools are running correctly.

Using an Anemometer

An important part of any weather station is the anemometer—the device that measures wind speed—because wind speed is an important factor in any weather forecasting. If it’s a cold day (below 32°F or 0°C, for instance), the wind speed plays an important role in how cold it feels (the wind chill). According to the National Weather Service’s wind-chill chart, a 15 MPH wind at 15°F makes it feel like 0°F, and a 20 MPH wind at 0°F makes it feel like 24 degrees below zero. Wind speed is important in this case in determining whether your extremities are going to freeze first or fall off first (both equally unappealing, if you ask me).

On the other hand, if it’s not particularly cold out, the wind speed plays a part in how fast the next weather phenomenon is coming at you. At 2 MPH, that sunny day is going to take another few days to reach you; at 50 MPH, you have only minutes before the cyclone destroys your house.

An anemometer can be a fairly complicated device, with bearings and shafts and switches and so forth; ours, on the other hand, is relatively simple.

Building the Anemometer

We’ll be using a rotary-shaft encoder, a rotating shaft, and some fins to measure the speed of the wind.

The rotary-shaft encoder we’re using from Vex robotics consists of a plastic disk with slits spaced evenly around its circumference. When power is applied, a small light shines through the slits in the disc and onto a photosensitive receptor on the other side. By counting the number of times the light is blocked by the disk (or, alternatively, the number of times the light shines through a slit) in a given span of time, it is possible to determine how fast the disc is spinning. It is also possible to determine how many times the disc has rotated, and this is, in fact, how rotary encoders are often used. If a rotary encoder is hooked to a robot’s axle, it’s a very good way of measuring how far the wheels connected to that axle have traveled, for instance. If the disc has 90 slits (as ours does), we know that one full rotation of the axle (one full wheel rotation) is 90 flashes of light onto the encoder’s photo receptor. Thus, we can tell the robot, “Go forward 30 slits,” and the wheel will advance exactly one-third of its circumference forward. If we know the circumference of the disc/wheel is 3 feet, we know the robot has just advanced 1 foot.

This may seem like a lot of unnecessary math, but it’s important for you to understand how the encoder operates. Once we attach the fins to the rotating shaft, we could (theoretically) figure out wind speed based on the circumference of the fins and the speed of the shaft. However, my experience is that it’s actually much easier to just experiment with known wind speeds and incorporate those speeds into our program, so that’s what we’ll do. To do that, you’ll need a partner—somebody who can drive you around at predetermined, sane speeds while you take wind-speed measurements. That means speeds of around 5–20 MPH, not 80.

To create your anemometer, peruse your local hardware store until you find a small, 1/8-inch square shaft that will fit in the square hole in the rotary encoder (see Figure 6-3).

Note

As of this writing, a 1/8-inch shaft fits perfectly in the rotary encoder’s hole.

Next, you’ll need a pinwheel or something similar. I used the windmill portion of a science kit that you can buy at your local craft store ( http://amzn.to/1koelSW , for instance). As you can see, the shaft fits perfectly in the windmill’s hole, and the directional fin attaches easily to the back of the encoder. (See Figure 6-4.)

The entire mechanism needs to rotate; that is, it needs to be connected to a device that can spin on an axis, like a weather vane, so we can determine the wind’s direction. This is where the Lazy Susan bearing set comes into play.

First, cut two slots in the end of the PVC pipe, into which your encoder will fit snugly (as shown in Figure 6-5).

Put the PVC cap on the other end of the pipe. Attach a light piece of wood to one side of the Lazy Susan bearing and then, as near to the middle of the rotation axis as you can, attach the PVC pipe and cap with a screw from underneath. Figure 6-6 shows one way to determine the center of the axis of rotation.

When you’re done, you should have an assembly like the one shown in Figure 6-7.

Correlating Revolutions per Second with Wind Speed

If the encoder is working as it should, the only step left is to correlate revolutions per second with wind speed, and the easiest way to do that is with a friend and a car. With your anemometer held out the window and your Pi connected to your laptop via an ad-hoc network (see the sidebar), have your friend drive for a few minutes at 5 MPH while you run the encoder script; repeat the process at 10, 15, and 20 MPH until you have enough data to correlate wind speed with RPS.

When I drove around with my anemometer hanging out the window, I got the RPS readings shown in Table 6-1.

Table 6-1

MPH Correlated to RPS Reading Using an Anemometer

MPH	RPS
5	5.8
10	9.23
15	10.8
20	11.7

The correlation of MPH to RPS is obviously a logarithmic relationship, which means we can use a little algebra (eek!) to calculate wind speed based on revolutions per second.

If you plot these values on a graph, you get Figure 6-8.

As you can see from the equation, the relationship between revolutions per second and wind speed is a logarithmic, not a linear, one. So, we’ll have to use the inverse logarithmic function, or e^x, to solve for wind speed in terms of revolutions per second. I don’t want to bore you with the math, so just take my word for it that

• wind speed = e^{((y+0.95)/4.3)}

We’ll be able to substitute that calculation into our final program, as you’ll soon see.

Hooking Pi To Laptop Via ad-hoc Network

If you’re like me, most of the work I do with my Pi is headless—I SSH (Secure Shell) into it or run a VNC (Virtual Network Computing0) server if I need to see the desktop, but I ordinarily don’t have a monitor, mouse, or keyboard connected to it. This works well if you’re connected to your home network, for instance, but what if there’s no network around? Luckily, setting up a wired ad-hoc network between your Pi and a laptop is pretty simple. An ad-hoc is simply a network connection between the Pi and another computer, such as your laptop, with no router or hub in between.

The easiest way to set this up is to take note of your Pi’s static IP address and adjust your laptop’s Ethernet port to communicate with that address. Let’s say your Pi has the address 192.168.2.42. Use a short Ethernet cable to connect your Pi directly to your laptop’s Ethernet port. Now, go into your laptop’s network settings. Chances are your computer is set up to receive an address automatically from the router via DHCP (Dynamic Host Control Protocol). Change that method to Manual and give your computer’s network port an address that coincides with the Pi’s subnet. In our example, a good address would be 192.168.2.10. If there are spots for it, fill in the subnet mask (255.255.255.0 will work in this instance) and the default gateway (192.168.2.1 in this case). If necessary, reboot your computer or restart your network manager.

You should now be able to log in to your directly-connected Pi via a standard terminal connection:

ssh -l pi 192.168.2.42

and you can work exactly as you would on your home network.

Connecting the Digital Compass

The digital compass we’ll use in this project has one purpose: to let us know which direction the wind is blowing. The one we’re using, the HMC5883L, uses the I2C protocol, so make sure you’re familiar with the information in the section “Using the I2C Protocol” earlier in this chapter before you continue.

Start by soldering the male headers that came with it to the HMC breakout board. The orientation is up to you; if you plan to make it standalone, you may want the headers facing up so that they’re easy to access. If, on the other hand, you’re planning on plugging the chip into a breadboard, by all means solder them facing down so that you can easily plug the whole unit into your board.

Once the headers are soldered to the board, connect the pins to your Pi with jumpers. VCC and GND go to the Pi’s #2 and #6 pins, respectively, and SDA and SCL to the Pi’s #3 and #5 pins. You’re now ready to use the smbus library to read from the compass, using a little math (eek!) to calculate the bearing based on the sensed x and y values. Now would be a good time to use the i2cdetect tool mentioned earlier to ensure you can read from the compass. Run the tool by typing sudo i2cdetect -y 1, and you should see the chip listed with address 0x1e (see Figure 6-9).

If it doesn’t appear, double-check your connections. (The other address you see listed in Figure 6-9, 0x60, is another I2C device I had plugged into my Pi.) When it shows up, start a new Python script to read from the device. We’ll use the smbus library’s I2C tools to read from and write to the sensor. First, start a directory on your Pi to keep all of your weather-station code together by typing

Now that you’ve created a weather directory in your home folder and have navigated inside it, type the following code into your new Python script:

After importing the correct libraries, this script sets up functions to read from and write to the sensor’s address using the smbus library. The functions read_byte(), read_word(), read_word_2c(), and write_byte() are all used to read and write values (either single bytes or 8-bit values) to the sensor’s I2C address. The three write_byte() lines write the values 112, 32, and 0 to the sensor to configure it for reading. These values are normally listed in the data sheet that comes with an I2C sensor.

The script then reads the current values of the x- and y-axis readings of the compass and calculates the sensor’s bearing with the math library’s atan2() (inverse tangent) function, first converting it to degrees with the library’s degrees() function. The x_offset and y_offset values, however, are subject to change, depending on your current geographic location, and the best way to determine those values is to simply run the script.

Run the script, preferably with a working compass nearby, and compare the readings you get to the compass readings. (The side of the board with the soldered headers is the direction in which the board is “pointed.”) You may have to tweak the offsets bit by bit to get the bearing to register correctly. Once it’s configured, you have a way to measure the wind’s direction; we’ll mount the compass to the anemometer’s rotating shaft so that we can read the direction when we assemble the final weather station.

Connecting the Temperature/Humidity Sensor

The temperature and humidity sensor we’re using, the Sensirion SHT15, is one of the pricier parts in this build. However, it’s also very easy to work with, because there’s no I2C protocol involved. You’ll first need to solder the included headers to it. Like the compass, the orientation of the headers is up to you. I tend to solder headers on with the board facing up, so I can see what each pin is as I plug the jumper wires into it. Of course, if I’m going to plug the unit into a breadboard, it means that I can’t read the pins, but that’s the tradeoff.

To work with this sensor, you’ll have to install the rpiSht1x Python library by Luca Nobili. Inside your weather directory (or wherever you’re working on your weather station code), download the rpiSht1x library by typing

When it’s done downloading (which shouldn’t take long, considering it’s only an 8KB download), you’ll need to rename it so that you can expand it. Rename the downloaded file by typing

and then expand the result by typing

Then cd into the resulting directory (cd rpiSht1x-1.2) and run

You now have the library available to you, so let’s try it out. With your SHT15 still connected as defined earlier, type the following code:

Save this code as sht.py and run it with sudo python sht.py. The script uses the functions defined in the Adafruit script—read_temperature_C(), read_humidity(), and calculate_dew_point()—to get the current values from the sensor, which we’ve connected to pins 7 and 11. Then, it performs a quick conversion for those of us not using the metric system and displays the results.

You should get a line with your current conditions:

As you can see, it’s a pretty self-explanatory library. Many of these libraries started their lives written for the Arduino to communicate with them, and thankfully they’ve since been ported to run on the Pi. (See the earlier side note regarding using existing code.)

Connecting the Barometer

Perhaps one of the most interesting parts of the weather station is the BMP180 barometer chip, if only because changing air pressure is one of the best indicators of what the weather is going to do next. In general, falling air pressure indicates a storm on the way, and rising air pressure indicates good weather ahead. That is an oversimplification, of course.

The BMP180 chip runs on the I2C protocol, so you’ll have to wire it up to your Pi’s SDA and SCL pins (pins #3 and #5) like you did with the compass. After soldering your headers to the board, connect VCC and GND to pins #1 and #6, and then SDA and SCL to pins #3 and #5, respectively.

To make sure everything is connected correctly, run sudo i2cdetect -y 1 and make sure the device shows up. It should show up as address 0x77, like in Figure 6-10.

Again, this device needs some external libraries to work. In this case, we’ll be using Adafruit’s excellent BMP085 libraries.

To grab the necessary library, in your terminal type

As we did before, we’ll need to rename the downloaded file so that we can use it. In this case, the file we downloaded is named NJZOTr. Rename it by typing

There’s nothing to install here, so we can jump right into using the library to communicate with the chip. In a new Python script in the same directory, enter the following:

As the script for the temperature sensor did, this little bit of code uses the prewritten library and its functions to read the necessary values from the barometer chip. When you run it, you should get something like Figure 6-11.

You can now read from all of your sensors, so it’s time to put everything together!

Connecting the Bits

An important part of building this weather station is putting everything (or at least the compass) on a rotating platform so that you can determine the wind’s direction. As you can see in Figure 6-12, I put all of my chips on a single breadboard and connected it to the Pi so that it was easier for me to mount everything (Pi and breadboard) on a rotating platform. With a decent-sized platform on your Lazy Suzan bearing, this shouldn’t be a problem.

Looking at Figure 6-12, you may notice how I wired it: I used the power rails running down one side of the board for the positive (+) and negative (–) connections, while on the other side I used the rails for the data (SDA) and clock (SCL) lines for the I2C connections. It’s the easiest way I’ve found to attach several different I2C devices to the Pi, since they share the clock and data lines. Figure 6-13 shows a better view of the wiring, in case you’re losing track of what gets connected to what.

With the anemometer mounted to your weather station base, you can now attach the Pi and the breadboarded compass, temperature sensor, and barometer chips. Because of the short leads from the rotary encoder, you may need to mount an additional breadboard to your anemometer mast, as you can see in Figure 6-14. Your finished assembly may look something like the figure. Power your Pi, and you’re ready to receive weather updates.

We’ll write the code so that the Pi queries each sensor every 30 seconds and displays the results to the screen. See the final code in the next section.

The Final Code

The final code is available as weather.py from Apress.com.

Summary

In this chapter, you built a weather station from scratch and installed the necessary sensors to keep tabs on the weather happenings, including barometric pressure, temperature, humidity, wind speed, and even wind direction. You’ve learned more about the I2C interface and should now have a good grasp of how to use Python functions to repeat tasks at a given interval. You’ve also done a lot of fabrication; now you can take a break because the next project, the media server, requires no construction whatsoever!

A Shopping List of Parts

This project requires almost no parts. All you’ll need is your Pi and an external USB hard drive large enough to store all of your files. The Pi should recognize most modern external drives, but I recommend that if you purchase a drive for this project, you plug it into the Pi and make sure everything works before you start transferring gigabytes of files to it to be streamed.

Using an NTFS Drive

The USB hard drive you use needs to be formatted as an NTFS (New Technology File System) drive. NTFS is a Windows format that often requires some special handling in order to be compatible with Linux. FAT32 was the format most often used prior to NTFS, and Linux and Unix had no problems reading from it or writing to it, but FAT32 cannot handle file sizes over 4GB, a limit easily exceeded by one high-definition movie file. Thus, we’ve moved to the NTFS format, which can handle file sizes up to 16TB without breaking a sweat. FAT32 also had issues with total drive sizes; depending on the size of file clusters, it could only format a drive up to around 127GB. NTFS formats, on the other hand, have a theoretical upper size limit of 256TB with a 64KB cluster—obviously much larger and more applicable to today’s larger file and drive sizes.

Keep those sizes in mind as you look at your current music and video collection and shop around for a drive on which to store them. Also remember: 1024KB equals 1MB, 1024MB equals 1GB, 1024GB equals 1TB. (Yes, you can round to 1000 in most cases; it’s a binary thing: 2¹⁰ = 1024.) Luckily, storage prices are dropping steadily, and you can most likely pick up a 2TB drive for under $150 US.

Because most drives purchased are preformatted with the NTFS format, let’s make sure your Pi can read and write to it by installing a program called NTFS-3g. Open a terminal and install it by typing

NTFS-3g is an open source, read–write NTFS driver program for Linux, Android, Mac OSX, and various other systems. It comes preinstalled on most Linux systems, but not the Pi (as of this writing), which is why you’ll need to add it.

Once NTFS-3g is installed, plug your drive into your Pi. You’ll probably be greeted with a popup window asking what to do; just select “Open in File Manager” and continue. Once you know you can read it (by viewing its files), make sure you can write to it by opening a terminal and creating a directory (which is only for testing), like this:

cd "My Book" (or whatever your drive is named—use ls to find the name)

If the test folder appears, you can move on. If it does not, make sure you installed NTFS-3g and reboot the Pi if necessary.

You may have noticed the fact that “My Book” is in quotes in the preceding command. That’s because while file names can contain spaces, you need to account for the spaces when you’re using the command line. If you need to change directories (cd) to a folder called My Book , just typing the following line will give you a File Not Found error because the OS looks for a folder named My and then stops looking:

The way to account for spaces in file names is to either use quotation marks around the name or escape the space with a backslash, like so:

We need to create a Media folder in the /media directory of the Pi; this is where we’ll be storing all of our music and movie files. We can create subdirectories in there later, but for now we just want to make sure that every time we boot up our Pi the external drive will get mounted to the same folder. This is because all of our other devices (clients) will be looking for that folder when we set them up, and we don’t want to have to reconfigure them to ask for a different folder every time we boot our Pi. To create that folder, do it as a root user:

To set the Media folder as a mount point, we need to edit a file called fstab and insert our drive’s information. First, we need our drive’s information. In your terminal, enter the following command:

This will list all of the drives, both virtual and physical, currently connected to your Pi. The results of my blkid , for example, looks like the screen shown in Figure 7-1.

As you can see, the disk mounted as /dev/sda1: "My Book" is the one we’re interested in, and what we need is that disk’s UUID (Universally Unique Identifier).

Now, we open the fstab file by typing

There will probably be a few lines already in the file. They follow this format:

We need to add our external drive and mount point to the file, with the correct file system and options. So, as an example, for a fictitious NTFS-formatted drive, I would add the following (each group of text here is separated by one tab):

The first entry is your drive’s UUID, the second is the folder we created earlier (which will become the mount point), the third is the volume type, and the last three are the necessary permissions and default options.

Once you’ve added to and saved your fstab file, mount all of the drives in it by typing

(which should force-mount all drives listed in fstab if they’re not mounted already), and you should hear your external drive spin up. Then, see if it mounted correctly to the proper folder by typing the following, which lists all currently mounted drives:

If everything shows up correctly, you can move to the next step in the process—installing Samba. If your drive does not show up correctly, double-check your fstab file, as errors in the UUID or the format of the text will cause the automatic mount to fail. It’s a picky file.

Installing Samba

As Samba’s website explains, “Samba runs on Unix platforms, but speaks to Windows clients like a native. It allows a Unix system to move into a Windows ‘Network Neighborhood’ without causing a stir. Windows users can happily access file and print services without knowing or caring that those services are being offered by a Unix host.” The name Samba comes from the SMB (Server Message Block) protocol, which is a part of the CIFS (Common Internet File System) put out by Microsoft in its attempt to get along with other operating systems without causing an outright mutiny.

This program, then, is what we need to install on the Pi so that your collection of Windows boxes can receive media files as well, like your collection of Mac and Linux boxes does. It is preinstalled on many Linux distributions; the Pi, however, is not one of them. Installing it is as simple as typing

Configuring Samba

Once Samba is installed, we need to configure it. It’s a good idea to make a backup of the current configuration file before you edit it so that you can just restore it should you royally mess it up.

To do that, use Linux’s cp command:

This command copies the smb.conf file to the smb.conf.orig file in the same directory. It needs to be run as sudo because the /etc folder can be edited only by the root user. When that’s done, you can open the file for editing by typing

You’ll be greeted by a rather large configuration file—don’t let it scare you. We only need to change a few settings. The size of the configuration file is indicative of how adaptable Samba really is; because it’s used all over the Internet, as both a web server and a file server, it’s important that users can change it to suit their unique needs. Our needs are actually rather simple and thus don’t require us to change many things in the program’s default settings.

The first setting we may need to edit is the workgroup. The workgroup is simply the domain that the Samba server (your Pi) will be a part of. As a home media server, the domain is what Windows calls a “workgroup”—your home network. Under the Global Settings, change

to the name of your local workgroup, if you have one. If you don’t have one set up, leave the workgroup setting as it is.

Then, uncomment the following line (by removing the hash symbol):

and change it to read

Under the Networking secton, change the interfaces line to read

Leave the following line as it is:

The last part to change is the Share Definitions section. This section is where you list and configure the fields and folders you want Samba to share with others. Scroll down to the bottom of that section and add the following lines:

This creates the sharing portion of your Samba installation to match the drive and folder created earlier. It also makes the folder browsable and creates the correct sharing permission for that folder.

Setting Linux Permissions

Linux file permissions are an interesting beast, and they could use some illumination because you’re bound to come across them in some fashion in your travels through Raspberry Pi country in the land of Linux. Each file or folder has three permission groups associated with it: the owner, the group, and the all users group. Those permissions are either r, w, or x, for read, write, and execute.

When you list the files in a directory with

you can see that each item in the directory is preceded by a line like this:

or

The first character is either a – (hyphen) or a d, which tells you that it’s either a file or a directory. Next, the permissions are listed in groups of three, in the order of owner, group, and all users. A file listed as -rwxrwxrwx means that the owner of the file, users belonging to the group that has been assigned to that directory, and all users all have read, write, and execute permissions to that file. If the file is listed as -rwxr-xr-x, on the other hand, it means that only the owner has write permissions (can write and save to it). The other two groups may only read the file and execute it.

If you need to change a file’s permissions, you use the chmod command, which can be done either explicitly or with a binary representation of those permissions. If you want to do it explicitly, the flags used for each group are u (owner), g (group), and o (all users.) For instance, if you wanted to change the -rwxrwxrwx file to be read only for all users, you would enter

which would change its directory listing to -rwxrwxr--. To do the reverse, you would enter

to restore write and execute permissions for all users.

If you’d prefer to use binary permissions, you can do that as well. Basically, each permission has a value; r = 4, w = 2, and x = 1. You add the integers for each group’s permissions and set them that way. So, a group’s rwx permissions would be a 7, and an r-x permission would be a 5. You need to set each group’s permissions if you do it that way; if a file currently has -rwxrwxrwx permissions, and you want to take away write permissions for the group and all users, you would enter

It can get a little confusing, but once you’ve worked a bit with permissions, it will all make perfect sense. In our Samba configuration file, you’ve set the mask and directory permissions to -r-xr-xr-x and -rwxrwxrwx, respectively, which is what we need in order to stream all files in that directory to clients.

Restarting the Samba Service

When you’ve finished editing the configuration file, restart your Samba service by typing

sudo service smbd restart

When it’s up and running again, go to a Windows machine on your home network and open a command prompt. At the prompt, type

net view \\192.168.xx.xxx

(substituting the IP address of your Pi, obviously). You should get something back like you see in Figure 7-2.

Connecting to your Samba share as a shared (network) drive is, unfortunately, slightly different in every version of Windows. Because this book is about the Pi, not Windows, I can’t go into all of the specifics for each version using a graphical interface. However, if you don’t mind using a command-line interface, the command to mount the Media folder on a Samba share located at 192.168.2.3 on the same domain is actually very simple. It looks like this

net use z: \\192.168.2.3\Media * /USER:pi /P:Yes

If everything on the Pi is set correctly, you should see your Media folder mounted as a Z: drive. However, Windows 7 is notorious for not wanting to play nicely with Samba shared folders (though many bugs seem to have been fixed in Windows 10). If you’re confident you have everything configured correctly but still can’t see the contents of the folder (you’re getting an Access Denied error, for example), try it with a different OS. Your Windows OS may be the problem.

Connecting with Linux/OS X

“But wait!” I can hear some of you screaming weakly from the back of the room. “What if we want to connect to our server with a Linux or Mac box?”

Well, first of all, if you are running a Linux box somewhere else in your house, you probably don’t need any help connecting to a Samba share. If, however, you’re using a Mac, it’s again pretty easy to connect. From your Finder, click “Go” and then “Connect to Server.” (See Figure 7-3.)

In the window that comes up, enter the address and shared folder and click “Connect.” (See Figure 7-4.) Enter the name and password you use to log in to the Pi in the next window, and the folder should mount as a shared drive, accessible from any Finder window. If you happen to be using Mac’s Mavericks (OS 10.9) or later, you may also have trouble connecting as “pi,” but you may be able to connect as “Guest.” This is an issue with OS X’s later versions and, unfortunately, is not something I can easily solve here.

You now have a working Samba installation you can use to share anything you put into the folder, and because of the permissions you gave it, you don’t have to worry about accidentally deleting a file in your Media folder from another device on the network. The only way to add to or subtract from the shared folder is from the Pi itself—a little security for your music and movies .

Kodi and Plex

If all of this seems a bit too complex for you, there are some other options available when it comes to using your Pi as a media server. The two most popular and effective solutions, in my opinion, are Kodi and Plex.

Let’s start with the Plex server, which is relatively new to the Pi. You’ll need to start by installing the HTTPS transport package, which is installed on some versions of Raspbian but not on others. In your terminal, enter

and either install it or listen to the message that tells you that you have it.

Next, you’ll need to add the dev2day repository to your list of repositories. To do this, you’ll need a crypto key for the repo. In your terminal, enter

Once you’ve installed the key, you can add the repo with

and then update your repo list with

Now, you can download the Plex server with

Once it’s installed, you’ll need to edit the configuration document in order to allow the server to run with the user “pi” (our normal user/login name). Open the document for editing with

and change the last line to read

Save your changes and then restart the server with

Finally, add some files to your server by using the server’s graphic interface. Open a web browser and, in the address bar, type your Pi’s IP address followed by :32400/web/. In other words, if your Pi’s address is 192.168.2.3, put 192.168.2.3:32400/web/ in the address bar and press Enter.

You’ll be prompted to log in to your Plex account (you may need to create one if you haven’t already) and then follow the prompts to add a media folder to your Plex server. It’s very easy to add files, even if they’re on an external hard drive (which is what you’ll probably end up doing). Figure 7-5 shows one step in the process of adding a library folder to your server; once you’ve added it, Plex will scan the files, download necessary information (such as movie poster icons, cast information, and so on), and then make it available to client devices.

All you need to access your media files then is a client device, such as a smartphone, tablet, smart TV, or even a Kindle Fire or Firestick.

Another option you have is to install Kodi. Kodi used to be known as XBMC (Xbox Media Center), but has since been updated. It’s commonly used with Linux servers such as the Pi and Android TV setups. There are a few different operating systems that Kodi runs on top of, but I happen to prefer OpenELEC, which stands for Open Embedded Linux Entertainment Center.

To install OpenELEC, you’ll need to put it on a new SD card so you don’t destroy the copy of Raspbian you’re using for all of your Pi projects. On your desktop machine, go to http://openelec.tv/downloads and expand the Raspberry Pi section. Choose the right build for your model Pi and follow their instructions for installing the image onto your SD card.

Once it’s installed and you’ve powered up your Pi, the OpenELEC installation will guide you through the process of connecting to the Internet (Figure 7-6), configuring SSH and Samba, and setting up your media libraries. It’s a little more involved than a Plex installation, but it’s also quite a bit more configurable, so it’s easy to get it exactly how you like it.

Where’s Python?

But wait! Where’s the Python in this chapter? Well, there is no Python in this chapter. This is a good example of a situation where programming is not necessary; the tools that are available are good enough just as they are, and sometimes it’s just as valuable to know when not to program as it is to know when to program.

Summary

In this chapter, you learned a little bit about how servers and clients operate, both on the Internet and over your home network. You learned about getting the Pi and other computers (notably Windows) to play well together and how to share all of your media files across your home network, accessible by any connected device, using three different free file-sharing programs.

In the next chapter, you’ll learn how to use the Pi to protect your home network—not from hackers, but from physical intruders.

Dogs as Security

Dogs (Canis lupus familiaris) are commonly known as man’s best friend, and they have been used as watchdogs for nigh on ten thousand years. They are descended from the wolf and come in all shapes and sizes, from the pint-sized Chihuahua to the giant Great Dane.

One of the jobs of the dog has long been to protect the home from intruders. They are intensely loyal and protective of their human family members and their “den” and will bark at, and even attack, intruders. To keep up this behavior, they require food—sometimes quite a lot of it. And while they are often cute and cuddly and great at keeping your feet warm on cold winter nights, the fact that they have to eat means, unfortunately, that they have to eliminate as well—a stinky undertaking for all concerned.

Dogs are also incapable of being upgraded. The last time I tried to plug a USB cable into my dog, she yelped and ran to my wife. And though dogs can be very cute when they stick their heads out of the window when you’re driving down the road, you can’t upgrade their drivers or use a package manager to download a more efficient gas-elimination program.

The upshot? Dogs are great for watching the house, but they have some serious shortcomings.

The Raspberry Pi as Security

The Raspberry Pi (Rubus strigosus Pi) is commonly known as the hobby-roboticist’s best friend, and it has been used to make all kinds of off-the-wall projects for at least six whole years. These devices are descended from the Acorn RISC Machine from the early 1980s and, as mentioned previously, come in various sundry versions: version 1, version 2, version 3, version 3+, the Zero, the Zero W . . .

The Raspberry Pi does not really have a specific job, but as a computer, it is well known that it will follow all instructions given it to a fault. If you program it to find all prime numbers between 1 and 10,000, it will do so; on the other hand, if you tell it to continue finding prime numbers until a pig flies overhead, it will continue computing until its processor burns out or until Porky grows wings. To do these amazing feats, the Pi does not have to eat, nor does it have to eliminate. The trade-off for the lack of metabolizing organic substances is that the Pi cannot keep your feet warm on cold winter nights. (Actually, I take that back; the version 3 can get kind of toasty when it’s doing some heavy-duty lifting, like video processing. But it’s still small and prickly.)

You can upgrade a Pi, however, with judicious use of the sudo apt-get install command. The Pi welcomes a USB input, and it can be programmed to use sensors to watch your house and its surrounding grounds and to alert you if those defenses are breached. Unfortunately—speaking from experience—people give you very strange looks if you drive down the street with your Pi hanging its head out of the window, but there’s no malodorous gas problem, so there’s that.

The upshot? The Raspberry Pi has some serious shortcomings, but those can be overcome to allow it to watch over your house. And since this is a book on the Pi, that’s what we’re going to use.

Using a Sensor Network

The home security system (and the weather center in Chapter 6) is based on the concept of a sensor network . If a computer is like a brain, sensors are the senses that allow it to gather information from and interact with the physical world. Cameras are like eyes, reed switches are like fingertips, and pressure switches are like toes that have been stepped on by a clumsy dog. Robots would be nothing without their sensors, and any robot brain that needs to interact with the physical world is entirely dependent on that network of sensors.

This, as a matter of fact, is one of the coolest things about the Pi—its ability to easily interface with physical things like sensors . Most modern desktops and laptops have had all of their interesting ports—such as the parallel and the serial port—taken away, left with nothing but a few lonely USB ports and an Ethernet port. This leaves them crippled, unable to easily interact with the “real” world without special equipment and the code to go with it. Meanwhile, the Pi can be plugged directly into a motion sensor via its GPIO pins and let you know, with a few lines of code, whether Slenderman is creeping about in the bushes behind your bedroom.

In our security system, we’re going to use several sensors: an infrared motion sensor, a pressure switch, a magnetic sensor, and a reed, or limit, switch. The motion sensor can be placed anywhere on the grounds. The pressure switch might be useful placed inside a doorway, where an intruder is likely to step. The magnetic sensor can be used to detect if a window is opened, and the reed switch can be used to determine if someone touches a trip wire. We can use the Pi’s onboard camera to take pictures if any sensors are tripped and access those pics any time. Last, we can use our home network to have the Pi send us a text message and/or email message should something interesting happen in our security network—kind of like the security company calling you if they detect an alarm.

This is the sensor network we’ll be working with. It’s kind of basic, but it’s also infinitely expandable. And although we’ll just be using one of each kind of sensor, you can easily add more if you want to (one magnetic sensor for each window in your house, for example).

Understanding a Pulldown Resistor

One important concept to know and remember any time you use an input with almost any circuit is that of the floating input and the pulldown (or pullup) resistor. Basically, whenever a pin (such as a GPIO pin on the Pi) is set to read input from a voltage source, such as a sensor, it is what’s called a floating input until some voltage is read at the pin. Before a voltage signal is sent from the sensor, the level at the pin could be almost anything. This unspecified floating voltage could seriously screw with your program; if you’ve programmed the self-destruct sequence to activate when the pin reads a 2.3V value, and the floating value happens to hit 2.3V, BOOM! We need a way to set the pin to a known value (such as a logical HIGH or a logical LOW) when nothing is being read from it.

The way to solve this problem is to use a pullup or pulldown resistor. This resistor connects the input pin to either Vcc or GND (pullup or pulldown, respectively). That way, if there is no input coming in, the pin will read either Vcc or 0, and we will know that value. This is often done with a physical resistor (10KΩ or 100KΩ, normally), but many development boards (including the Pi) will let you do it “virtually” via software—a huge advantage when you’re working with limited space. Using the GPIO library, you can declare a pin as INPUT and, at the same time, “pull it down” as if with a pulldown resistor with the following syntax:

This defines the value read at pin #11 as LOW until it receives voltage from the sensor; at that point, that voltage is pulled HIGH, and the program can act. When the HIGH value disappears, the pin is again pulled LOW until the process repeats. A pullup resistor does almost the same thing, except the pin is pulled HIGH (to Vcc) until an input appears.

A Shopping List of Parts

Some of these parts are optional, of course; it all depends on how thorough you want your security system to be. You can even add items to your list as your security system grows. Each sensor merely adds to your sensor network, expanding your system’s reach.

Connecting to Your Network Wirelessly

When you set up your Pi as the main controller of your security system, it will have to connect with your home’s network to allow you to remotely log in and administer it and to send you a text message to inform you of an infraction. When you connect to your network, you have the choice of going wired or wireless. Each option has pros and cons, of course, but I highly suggest you use a wireless connection. This is mainly for two reasons: a wireless connection allows you to place the Pi anywhere without having to run Ethernet cable to its location, and a wireless connection is also more secure—a burglar can cut a wired connection to your Pi to render it useless, but not so with a wireless connection.

The main thing you’ll need to do is set up your Pi to have a static IP address. This will allow you to log in to your Pi remotely from anywhere, regardless of whether it has been powered off since your last remote login. If you leave the Pi to receive its IP address dynamically from your home router, it’s possible the IP address will change if the Pi has to reboot, meaning you’ll be unable to log in (because you won’t know what the new address is).

Luckily, setting up a static IP for your Pi’s wireless connection is not difficult, though it can get confusing since the methodology seems to change every time a new Pi model is released. You’ll need to know your router’s address, which is normally something like 192.168.0.1.

In a terminal prompt on your Pi, enter

and scroll to the bottom of the file. This is where you’ll put the information for your particular network and your particular address. Let’s say your router has an address of 192.168.0.1, and you would like your Pi to have an address of 192.168.0.4. Enter the following at the bottom of /etc/dhcpcd.conf:

The first line determines which interface, wired or wireless, you’re setting. The second line gives the Pi’s new static address, and the third line gives the router’s address. Finally, the fourth line sets the DNS server to Google’s DNS.

Once you’ve entered that information, reboot your Pi. Depending on your wireless setup, you may need to use the Pi’s desktop interface to add the password for your personal network. Once this is done, however, your Pi will always have the same address. Now, even if it needs to reboot, you’ll always be able to log into it, using that address to administer it.

Now, to use that static IP, you’ll need to have an SSH server running on your Pi. Depending on how you first set up your Pi, you might have one running already. The easiest way to get your SSH server up and running is to run your raspi-config tool by typing

at the command line. You’ll be greeted with the raspi- config screen (Figure 8-1).

Cursor down to option #5, Interfacing Options, press the right arrow key to highlight <Select>, and press Enter. Move the cursor down to P2 SSH and again highlight <Select> and press Enter. Make sure that <Yes> is highlighted on the next screen (Figure 8-2) and press Enter.

Then, back out of the raspi-config tool by selecting <Finish> and pressing Enter. Finally, reboot your Pi by typing

in the terminal, and your SSH server should be up and running. You can now remotely log in to your Pi from anywhere. If you’re using a Windows machine, you’ll need to download the free tool PuTTY in order to log into your Pi. If you’re using a Mac or Linux box, ssh is enabled already. Just use the following command:

Enter raspberry at the password prompt, and you’re in! With PuTTY, enter your Pi’s IP address in the box, add the username and password, and click “Connect.” You can now administer your Pi via the command line from anywhere.

Accessing the GPIO Pins

As stated before, and as you’ve already seen if you’ve read some of the other chapters in this book, the Pi’s GPIO pins are the way we interface the Pi with the physical world, such as sensors, servos, motors, and lights. In order to do this, we use a Python library especially designed for this purpose: RPi.GPIO.

To work with the library, you may have to manually install two other libraries. (It depends on which version of Raspbian you’re running.) First, make sure your Pi is up to date by typing

Then, install the Python development packages by typing

Now, in order to access the pins, you call

in the first lines of your program and then configure it by typing

which lets you identify the pins as they are labeled on a standard pinout diagram (as shown in Figure 8-3).

Once you’ve set the mode, you can set each pin to be either an input or an output. Users of the Arduino will probably recognize the concept here:

and so forth. Once you’ve set a pin as an output, you can then send voltage to it (turn it on) by using

or

and subsequently turn it off by using

or

When you configure a pin as an input, remember to set a pullup or pulldown resistor as discussed earlier.

Setting Up the Motion Sensor

One of the most important parts of a home security network is likely the motion sensor (shown in Figure 8-4), with a few caveats. You can’t rely solely on your motion sensor, because the moment you do, it’ll be set off by a neighborhood cat or possibly a Yeti (not necessarily a bad thing). If, however, you use it in addition to all the other sensors, you may have good luck with its results.

The sensor we’re using, by Parallax or a close clone, detects motion by detecting changes in the infrared (heat) levels emitted by objects in the surrounding environment. Like most sensors, it then signals that a change has been detected by outputting a “HIGH” or “1” signal on its output pin. It has three pins: Vcc, Gnd, and Output.

The pins are (from the left in Figure 8-4) OUT, +, and –. A nice feature of this particular sensor is that it can use any voltage from 3V to 6V. To use and test it, connect the (–) pin to the Pi’s ground pin (pin #6), connect the (+) pin to the Pi’s 5V pin (pin #2), and connect the OUT pin to one of the GPIO pins.

To test the sensor and our coding prowess, we’ll start by setting up the GPIO pins accordingly. We can use a simple setup to test our code—an LED on a breadboard that will light up when the sensor is tripped. Start a new Python script (let’s call it motion.py) with nano motion.py and enter the following:

That’s it for the test code! To test it, first connect the (+) pin on the sensor to pin #2 on the Pi. Connect the OUT pin to pin #11 on the Pi. Connect the (–) pin to a common ground line on your breadboard. Connect that ground line to a ground pin on the Pi, such as pin #6. Finally, connect pin #13 on the Pi to the positive leg of your LED (through a resistor) and connect the negative leg of the LED to the common ground line. You should end up with something like what you see in Figure 8-5.

When you run the preceding script (remembering to use sudo because you’re accessing the GPIO pins), the LED should light up when you move your hand around the sensor, and then it should go out again after a few seconds of nonmovement. If it doesn’t work, check your connections and your parts—a burned-out LED can cause all sorts of troubleshooting headaches, believe me!

Leave the sensor attached as it is, as we’ll be using it in our system, and let’s move on to the reed switch.

Setting Up the Reed Switch

The reed, or limit, switch is a useful tool in many situations, not the least of which being our security system. It’s often used by robots to determine the limits of movement, whether it’s driving into a wall or closing a gripper around an object. Its concept is simple: the switch is normally open, letting no voltage through, and it has an armature protruding from the body of the switch, like a long lever. When an outside object presses on the lever, it closes the switch, sending voltage through the circuit—in our case, to the INPUT pin on the Pi that’s listening for a signal. The limit switch we’re using is also called a “sub-miniature snap-action switch.” (See Figure 8-6.)

The long arm protruding from the body of the switch allows objects that are far away to close the switch’s contact—the small hump protruding from the switch. It has three terminals, but we’re only going to use two because we’re only interested in when the switch closes.

In our case, we’re going to use a limit switch to determine if a trip wire has been pulled. You can mount the switch on a wall and run a thin thread or fishing line from the opposite wall to the switch’s lever. Position it so that if someone were to walk into the thread, they’d pull the lever down, activating the switch.

Because we’re using a physical switch, rather than a sensor like the motion detector, it’s important that I introduce you to the concept of debouncing . A common aspect of physical switches is that, because they’re often made of spring metals, when they are first activated they tend to bounce apart one or more times, often in almost microscopic increments, before making a steady contact. The result is a very fast on-off-on-off-on-off “chatter” before the voltage settles at a steady HIGH or LOW. To combat this, we debounce the switch by reading from it only when it’s no longer bouncing back and forth, like so:

This little script illustrates the concept quite nicely. It ignores a button press if it occurs less than 0.05 seconds after the last one.

So, to test our switch, let’s hook it up to some GPIO pins and make sure we can read the input when its state changes. Just using the switch, connect your Pi’s power pin (#2) to the switch’s leftmost pin, as shown in Figure 8-7. Then, connect the middle pin to your Pi’s pin #11. Try the following code:

When you run this script (remembering to use sudo), pressing the switch will send voltage directly through it from pin #2 to pin #11, thus registering as HIGH at pin #11. It’s a debounced signal, and the Pi should print “Button pressed” when you press the button. Congratulations! You’re able to read when a switch is pressed!

Let’s move to the next switch.

Setting Up the Pressure Switch

The pressure switch is very similar to the limit switch, though it looks quite different (Figure 8-7.)

Rather than a physical lever and a button, a square pad is used that simply registers pressure as a change in voltage. For this reason, it’s even easier to connect than the limit switch. Connect your Pi’s pin #2 to one of the leads, and connect the other lead to pin #11. Then, run the same script as you did for the limit switch and test it by pressing down on the pad with your finger. Voilá! You’re now reading a value from a pressure switch! This is perfect for reading a footstep from underneath a welcome mat, for instance.

Connecting the Magnetic Sensor

The magnetic sensor (shown in Figure 8-8) is a little device that, while not commonly used outside of certain specific applications, can come in handy for applications like ours. It measures the surrounding magnetic field and sends a signal when that field changes. For that reason, it is very good at determining when the relative positions of two pieces of metal have changed.

To make sure we don’t get any false readings, we can use some small external magnets to influence the sensor; the one we’re using comes with two small neodymium magnets for just that purpose.

To test our magnetic sensor , we can again use the switch.py code we’ve been using. Connect the jumper wires that came with the sensor to the connector block on the sensor, then connect them to your Pi: red to pin #2, black to pin #6, and white to pin #11. Now, just change the code to read

and run the script. Your terminal will remain blank until you wave the magnet past the sensor. (You might have to experiment with different distances and speeds. My experience is that the magnets have to pass pretty closely to register.) At that point, it will tell you “field changed.” After a little experimentation, you’ll know just where you’ll have to mount the magnet in order for the change in field readings to influence your security system. Now you can mount the sensor on one pane of a sliding window, for instance, and a magnet on the other pane, and should the window slide open, the magnetic sensor will register the movement of the magnet.

Setting Up the Pi’s Camera

Finally, one of the features that makes the Pi attractive as a security-system lynchpin is its ability to take pictures from a small built-in camera. While this means that the Pi must be positioned in a strategic location to pick up anything interesting, the Pi is so small that finding a good place for it shouldn’t be a problem.

To take pictures, you’ll have to have two components working on your Pi: the wireless and the camera. I discussed the wireless setup earlier; the camera can also be enabled with the raspi-config tool, if you haven’t configured it already.

Once you’ve enabled the camera, you have two commands you can use: raspistill (to capture pictures) and raspivid (to capture video). Each can be used with various flags and options to change the frame size, capture rate, and other configurations.

We’re interested in taking still pictures, however; streaming video via live feed, while possible, requires a few extra software tools that can be difficult to set up. Taking a picture is a simple call to raspistill from the command line, or the use of the picamera Python library (which is what we’ll use). To try it out, enter the following in a new Python script:

and make sure that it’s been enabled with your raspi-config tool. A still image labeled “image.jpg” will be stored in the current directory. We can put this picture-taking functionality in a take_pic() function and call it whenever a sensor is tripped. We then have evidence, should we need it for corroboration!

Sending a Text Message from the Pi

In my opinion, having your Pi send you a text message when something unusual happens is one of the coolest parts of the project, and it’s particularly useful if you’re going out of town. A notification from your Pi can let you know that you need to call your neighbor (or the police) and have them check on your house. It’s really pretty simple: the Pi uses the local network to send an email message, which is then translated by your mobile carrier into an SMS, or text message.

You’ll need an email account that’s web-accessible; most of us have a Gmail or Yahoo account, for instance. You’ll also need to know how to send a text via email with your mobile carrier. Each carrier is slightly different, but the basic concept is the same—sending an email to a certain number (<mobile_number>@txt.<carrier>.net, for example) has that email delivered as a text. I use AT&T, and if you send an email to 19075551212@txt.att.net, it will be delivered as a text. Check with your particular carrier as to what address and format to use; if the information isn’t easily found on their website, ask a tech. Then, using Python’s smtplib library, you can send an email to your phone.

It’s probably easiest if I just show you with the following code:

Calling the send_text() function with a string such as “OMG I’m being robbed!” will send you a text message. Obviously, this code is designed to work with AT&T and uses a Gmail account. You’ll need to modify it as necessary for your carrier and email provider. Gmail’s smtp access is through port 587, as you can see in line 9 in the preceding code; this may differ for Yahoo or MSN. You can call this function when you detect an input at any of your sensors, and you can even adjust the string sent according to which sensor is tripped.

Implementing the Callback

There’s one significant idea left to explore in this project, and that is the concept of the callback . You may have noticed that there’s no easy way to check each switch; you have to continue to “poll” each switch and hope that nothing unusual happens while you’re doing something else. Not a big deal if you have only three or four switches and sensors, but should you start adding to your network, the delay between something happening and your being notified about it can get unwieldy quickly; limit switch #2 could get tripped while you’re checking magnetic sensor #16, and you won’t know about it for another two seconds. By that time, of course, the intruder could have snuck by the trip wire and be well on his way to breaking all of your dishes or stealing your Star Wars memorabilia.

Luckily, Python (and the Raspberry Pi) have an answer to that switch-checking problem. It’s embedded in the RPi.GPIO library: the threaded callback interrupt. What this allows us to do is to start a different program thread for each switch. Each thread will go into a “waiting” mode, doing nothing, while the rest of the program (and the rest of the threads) go on about their business. If and when the switch gets tripped, it immediately issues a callback, or interrupt, to the main program to let it know (“Hey! I’ve been tripped over here!”), and then it performs whatever function we want it to. In this way, we can be sure we won’t miss an important button press or switch trip. Meanwhile, all of the other threads continue their holding pattern. At the bottom of this pattern, one switch functions as a base; if that one switch is tripped, you can end the program. Otherwise, it continues inside a while loop.

This callback feature is accomplished using either one of two functions: GPIO.wait_for_edge() or GPIO.add_event_detect(). GPIO.wait_for_edge() does just that—waits for a rising or falling edge on any particular pin and then acts when it detects that edge. GPIO.add_event_detect(), on the other hand, waits for a rising or falling edge on a particular pin and then calls the function declared in its parameters. You can see them both in use in the final code later in this chapter. Just be aware that for each sensor or switch, we have a unique callback function—one that is unique to that sensor—so that we know exactly which switch has been tripped.

Connecting All of the Bits

Now that we’ve determined how to use all of the pieces of this puzzle, let’s quickly go over how to connect everything.

You’ll need to use the Ethernet cable to make all of your connections; it’s strong, easy to work with, and (mostly) waterproof. Strip the outer casing to reach the wires inside and chop all but the two or three wires you need to connect each sensor to your Pi. You’ll need a small breadboard to place next to the Pi because everything should share a ground.

Find a good place to mount your Pi, where you can plug it in (no worrying about batteries) and mount the camera so that it can take good pictures of the action. Once you’ve found a place, you can use poster putty to hold everything in place. You may want to use a plastic or metal project box to keep everything together.

Finally, find good places for all of your sensors. Remember, they don’t need to be in sight of the Pi: as long as you can run Ethernet cable to them, it’s a good spot. Attach the cables securely and in such a way that nobody trips over them. Connect all of the negative wires to your common ground row on your breadboard, and then connect each positive wire to a GPIO pin. At this stage, it’d probably be a good idea to write down what sensor is attached to which pin so that you can reference it in your code.

The Final Code

That completes all the individual parts of this project. All that’s left is to put them all together in your final code, like so (you can download the final code file, called home_security.py, at apress.com):

Summary

In this chapter, you learned about what sensors are, the concept of a sensor network, and how to hook different sensors to your Pi’s GPIO pins. You set up the limit switch, pressure switch, magnetic sensor, and motion sensor (which we will also use in the Pi-powered cat toy in the next chapter). With the knowledge you’ve gained here, you now have the ability to create a full-sized security system, with its breadth limited only by the amount of sensors you have and how much wire you’ve got to tie them all together.

A Shopping List of Parts

A nice feature of the cat toy, aside from its being simple and homemade, is that the parts are actually pretty inexpensive. You will need the following:

• A Raspberry Pi

• Two standard (not continuous) servos—I recommend the Parallax 900-00005 ( http://www.parallax.com/product/900-00005 ), but any model will work

• A cheap laser pointer, which you can purchase at a pet store for around $10 US (see Figure 9-1)

• A PIR motion sensor ( http://parallax.com/product/910-28027 )

• Glue/epoxy

• Miscellaneous wires (red, black, and so forth)

• Flat-headed screw

• Electrical tape

• Popsicle stick

• 9V battery

• A container on which to mount everything—I used a short length of PVC pipe

The Concept Behind the Toy

The key to making this toy work is random motion . If you program the toy to make a series of concentric circles, one after another, and then repeat the pattern, it won’t take long for your cat to recognize the pattern and get bored. However, by using Python’s random or randint functions, you can randomize the patterns and keep your cat (and possibly your toddler) entertained.

Another thing to keep in mind is that you will be randomizing the motion on two axes—the x-axis and the y-axis—while keeping the motion within certain bounds (which is where the parameters of the randomizing functions and the movement extremes of the servos come in). You will be using two servos, but they’ll be joined together so as to control the motion of one laser pointer. To control the servos, like in several other projects in this book, we’ll use the Pi’s GPIO pins and Python’s GPIO library. Another nice thing about this project is that the servos end up drawing so little power that they can be sourced with a simple 9V battery. You still need to power them separately from the Pi (always a good idea, regardless of the project), but you don’t need a fancy battery setup as you do with many other projects.

Creating and Using Random Numbers

You’d think creating and using random numbers would be simple. Just call a function, get a random integer, and proceed. While that may be how it works in practice and is all that most of us think of, the actual process of randomizing output is fascinating—it’s actually the subject of intense study by many computer scientists and mathematicians. (See the sidebar “Oh, the Randomness.”) To get a random number in Python, you can use several built-in functions. The first is, appropriately enough, the random() function. This function returns a float (a floating point decimal number). It takes no parameters, returning instead a random number between 0.0 and 1.0. This is often very useful, but for our purposes we’re going to need somewhat larger numbers, preferably in an integer format, which can be done with the randint() function.

According to the Python docs, randint(a, b) returns a random number n, such that n is between a and b, inclusive. In other words, the following code

should return 1, 2, 3, 4, 5, 6, 7, 8, 9, or 10. We’re going to use it to generate positions for the servos we use.

Using the GPIO Library

Now that you have an idea of how we’re going to generate our random numbers, you need to know how to control the servos that will be attached to the Pi. Luckily, there is a Python library that is specifically designed for this purpose and comes preinstalled on the Pi. This library enables us to access the Pi’s General Purpose Input Output (GPIO) pins and is called, simply, RPi.GPIO.

You may have to manually install the Python development libraries if you haven’t done so already. First, make sure your Pi is up to date by typing

and then install the packages by typing

We can now start typing our final code for this project. Remember, it’s available as cat-toy.py from Apress. com . Now, to access the Pi, call the following in the first lines of your program:

Then, configure it by typing

which lets you identify the pins as they are labeled on a standard pinout diagram, shown in Figure 9-2.

Once you set the mode, you can then set each pin to be either an input or an output. Users of the Arduino will probably recognize the concept here, but this is what you type for the Pi:

and so forth. Once you set a pin as an output, you can then send voltage to it (turn it on) by entering

or

Subsequently, you can turn it off by entering

or

We’ll use two pins for servo controls, one pin to power the laser pointer, and another to read input from the IR sensor.

Controlling the Servo

Servos are an important part of many different applications, from radio-controlled vehicles to high-end robotics. A servo is, at its heart, nothing more than a DC motor. However, with the help of software you can have extremely fine control over the motor’s rotation. For example, if you need it to rotate 27.5 degrees and then stop (and assuming the servo is capable), you can send it that command programmatically.

So, how do you do that using the GPIO pins on the Pi? Unfortunately, you can’t just plug the servo’s signal wire (the white one, usually) into a GPIO out pin, give it a positive and negative voltage, and expect it to work. It may, but then again it may not.

The answer lies in how to control servos. As analog pieces of hardware, they predate most of today’s digital hardware, including the Pi. They operate using pulse-width modulation (PWM) signals. To control them, you must be able to send PWM signals via whatever mechanism you’re using, whether it’s an Arduino pin, serial cable, or Raspberry Pi’s GPIO pin. If you want to set a servo’s position, you need to send it regular pulses of current—50 times a second is an average pulse speed—rather than one long pulse. That 50 times a second translates—if you’re wondering—to one pulse every 20 milliseconds (ms).

The length of that pulse, moreover, is what determines the position of the servo. An on pulse of 1.5ms, for example, sent every 20 milliseconds, will send the servo to the center position. Shorter pulses will turn it one direction, while longer pulses will send it the other. Thus, by precisely timing the length of the pulses you send to the servo, you can precisely position the servo head.

The graph in Figure 9-3 illustrates this best.

If you want to send the servo to the neutral “zero” position, you send it a 1.5ms on pulse every 20 milliseconds, which can be thought of as a duty cycle of 7.5 percent. Likewise, if you want to turn it counterclockwise with a 0.5ms on pulse, it has a duty cycle of 2.5 percent, and a longer 2.5ms on pulse translates to a 12.5 percent duty cycle. In other words, the servo is given a “high” pulse 2.5 percent, 7.5 percent, or 12.5 percent of the time.

These directions are applicable to standard—not continuous—servos. The difference is that while standard servos use the length of the pulse to determine their final position (in degrees from center), continuous servos use the length of the pulse to determine the speed at which they should turn. A standard servo will move to its destination position and then stop until a new command is sent; a continuous servo is almost always moving, with the speed of the movement determined by the pulse lengths. And while you could conceivably use either type of servo for the cat toy, it makes more sense to use standard servos and thus have both the capability of exact positioning and the ability to stop completely, allowing the cat to—temporarily, at least—“catch” the little red dot.

The problem with this method of moving servos, however, is that it can be difficult to use the Pi and Python to send millisecond-length pulses to the GPIO pins. Like all other processes running on the Pi, Python is constantly being interrupted by system-level running processes, making the precise timing of pulses by a Python program impractical, to say the least. However, once again, the GPIO library has what we need: you can use the library to set a GPIO pin as a PWM pin, giving it the duty cycle necessary to send the correct-length pulses to the pin.

So, while it is theoretically possible to script something like this:

the results would most likely be something completely unexpected, if it worked at all. Instead, what we can do is use the RPi.GPIO library function to set the servo’s signal pin (pin 11 in our example case here) to be a PWM output pin by entering

The 50 in this case sets the pulses to 50Hz (one pulse every 20 milliseconds), which is what the servo requires to work. We can then set the pin’s duty cycle to 7.5 percent by typing

If we put p.start(7.5) inside a while loop, the result is that the servo will move to the center position and then remain there. Changing the duty cycle with p.ChangeDutyCycle() will allow us to move the servo in different directions, which is what we’re going for with the cat toy. So, for example, to see your servo move back and forth, try the following script:

Running this script should make your servo sweep back and forth, pausing for a second between each direction change.

All that’s left for our cat-toy script is to implement some random numbers. Those numbers will determine which servo moves, in which direction, and for how long. The result should be a rather random path in two dimensions.

Constructing the Servo Mechanism

Our cat toy is going to sweep a laser pointer in two directions, which means we need a servo capable of the same thing. While servos aren’t generally capable of two-dimensional motion, we can easily construct a pan-and-tilt servo mechanism using two normal servos attached to each other.

All you need to do is mount the body of one servo to the horns of the other. To make a secure connection, you may need to remove the screw holding the servo horns of the base servo (let’s call it the x-axis servo to keep the task simple) and file down the plastic a bit. You’re trying to flatten the top of the servo as much as possible to mate it tightly with the body of the other (y-axis) servo.

When it’s as flat as it’s going to get, use a strong epoxy or adhesive to glue the y-axis servo body to the horns of the x-axis servo. I used Gorilla Glue and got the result shown in Figure 9-4.

The laser pointer can now (after some not-so-minor modifications) be mounted to the top (y-axis) servo.

Constructing the Laser Mechanism

We’re going to use a standard laser pointer, but we’re going to modify it in a few important ways. The most important way is that instead of using batteries, we’ll power it using the Pi’s GPIO pins. This is important because it enables us to turn the laser on and off programmatically rather than by fussing with the push-button switch.

To modify the laser pointer, you’ll need some electrical tape and a flat-headed screw about two inches long and with a head just a tad smaller than the inside diameter of the laser pointer. Wrap the screw with the electrical tape so that it fits snugly inside the body of the pointer. If necessary, when you’re done, cut the end of the tape (as shown in Figure 9-5) so that the screw’s point is exposed.

Remove the laser pointer’s base and take out the batteries. Push the screw, head first, into the body of the pointer so that the screw head is pushing down the inner spring that is normally held down by the batteries. You may have to play with the amount of tape you use to wrap the screw; you want it to be a tight-enough fit to press down the spring and stay in place without being in danger of moving.

We also need to tape the laser pointer’s power button down so that it’s always on. As I said, we’ll be taking care of powering the pointer from the Pi. Wrap a piece of tape around the pointer to hold down the button.

At this point, you should have something that resembles the image in Figure 9-6.

If you want to test your work (never a bad idea), use a few alligator clips to connect the screw’s point to pin #6 (the ground pin) on the Pi, and then connect the body of the pointer to pin #1 (3.3V). The laser should light, showing you are powering it directly from the Pi’s power pin. If nothing happens, make sure the screw head is pressing on the spring, the power button is securely taped down, and all your connections are solid. Once the connections are solid, you’re ready to mount the laser to your two-dimensional servo contraption.

Connecting the Laser to the Servo

Connecting the laser to the servo is probably the easiest part of the project. If you’re like me, you don’t want to permanently attach the laser to the pan-and-tilt servo setup you’ve got, because that setup can come in handy with other projects. So, we need to find a way to temporarily attach the laser to the servo horns.

I used a popsicle stick to pull this off. We can glue the laser to the popsicle stick, and then screw the stick to the servo horns. This can be done with either the screws that came with the servo (you still have them, don’t you?) or the smallest screws you can find in your workshop. Trust me—those are really tiny holes in the servo horn.

Using a strong glue (again, I like Gorilla Glue), affix the laser assembly to the popsicle stick. When the area is dry, use the small screws to attach the popsicle stick to the servo horns. When you’re done, you should have a device that looks like Figure 9-7.

A word of caution here: take some time and position the laser pointer and its associated servo so that the laser can spin freely no matter where in the cycle the two servos are. Obviously, the easiest way to do this is to remove the screws holding the servo horns to the servos and reposition the horns based on the servos’ travel arcs. Then, run the two servos through all possible positions and make sure that your mechanism doesn’t bind at any point in its motion. Since standard servos only travel through an arc of around 180 degrees, you should be able to find a suitable position for all the parts.

The last integral part of this project is connecting the motion sensor.

Connecting the Motion Sensor

Not only does the motion sensor (shown in Figure 9-8) save your batteries, but it also seriously contributes to the cool factor: your toy turns on only when your cat (or dog, or roommate, or a Sasquatch) comes near it.

Hooking up the IR sensor is simple: the positive and negative pins are connected to power, and the third pin (the leftmost pin in Figure 9-8) is connected to one of the Pi’s GPIO pins configured as an INPUT. When the sensor detects motion, it outputs a HIGH signal on the output pin, which then travels to the Pi’s INPUT pin. With the GPIO pin configured as an INPUT, we can read that signal and execute the Python script controlling the toy only when that signal is present.

Before we continue, I need to discuss the important concept of a pullup or pulldown resistor, which I also talked about in the previous chapter. Whenever you have an input in electronics, if that input is not directly reading anything, it is referred to as a floating input . That means the value read from that input could be absolutely anything. We need to define that input’s “empty” state so that we’ll know when that input changes.

To define an input’s “empty” state, we normally connect a resistor (10K or 100K are common values) between the input and either a positive pin (thus creating a pullup resistor) or a ground (thus creating a pulldown resistor). Which one you use is not important—it’s just important that the input is pulled up or down. Thus, if nothing is being read on the pin, and it’s connected to a ground via a pulldown resistor, it will read “0.” When it no longer reads “0,” we’ll know that it’s receiving input.

In the case of our IR sensor, we need to define the value read at the pin when no motion is detected as “LOW,” so we’ll use a pulldown resistor. Luckily, to keep this process simple, the GPIO library allows us to do that in code when we define a pin as an input, like this:

If we connect our IR sensor’s OUT pin to pin 11 on the Pi and initialize that pin with the preceding line of code, everything read on pin 11 will be “LOW” until movement is detected. At that point, the pin will read “HIGH,” and we can call the function that turns on the laser and moves it around.

To test the sensor and our coding prowess, we’ll set up the GPIO pins accordingly. We can use a simple setup to test our code; an LED on a breadboard that will light up when the sensor is tripped. In a Python script, enter and save the following code:

That’s it for the test code! To test the code and the sensor setup, first connect the (+) pin on the sensor to pin #2 on the Pi. Connect the OUT pin to pin #11 on the Pi. Connect the (–) pin to a common ground line on your breadboard. Finally, connect pin #13 on the Pi to a resistor and then the positive leg of your LED, and connect the negative leg of the LED to the common ground line. You should end up with something like the configuration you see in Figure 9-9.

When you run the script (remembering to execute the code as the superuser, or sudo, since you’re accessing the GPIO pins), the LED should light up when you move your hand around the sensor, and then go out again after a few seconds of non-movement. If it doesn’t work, check your connections and your parts; a burned-out LED can cause all sorts of troubleshooting headaches, believe me!

If everything works as planned, we can now wire the toy and complete all the connections.

Connecting All the Bits

After you successfully test the infrared sensor, the code needed to operate it, and the code used to work the servos, and when everything is attached to everything else, it’s time to wire everything up and make all the connections. This is where a small breadboard comes in handy—you can connect all your grounds together (an absolute necessity) and run power to everything as needed. I used a 9V battery for the two servos, but feel free to try different batteries as you prefer. It’s not necessary to use a rechargeable RC battery in this case, as we do in some other projects, because weight isn’t really an issue, and the servos don’t run the battery down too fast, as they’re not constantly running—thanks to the sensor. However, you do need to power the servos with a separate source from that which you’re using to power the Pi; otherwise, you’re likely to get constant freezes and crashes. With a breadboard that has two power channels, you can run the +9V down one positive channel, connect pin #2 on the Pi to the other positive channel, and then wire the two negatives together. Then, you can connect the laser power and the IR sensor power to the Pi’s power channel and connect the two servos to the 9V power channel, and all your grounds will be tied together. See Figure 9-10, which shows the various parts connected together using a breadboard.

Figure 9-10 is not totally accurate, as the laser pointer is physically attached to the servos, but you can see the electrical connections. The pointer is powered with pin #11, the servos are powered with pins #13 and #15, and pin #19 is the sensor input. Then, everything is given its respective voltage to make it work.

There are a few mechanical engineering tasks involved in the building of this toy, not the least of which is the best way to permanently attach the power and ground wires to the laser pointer. While alligator clips are fine for testing, as soon as the servos start jerking the pointer around in circles, they’re going to come undone.

The best solution to this is to solder the wires to the pointer parts. If you can, use sandpaper to roughen the point of the screw and the pointer casing. If you have room, drill a small hole in the pointer casing to hold the positive wire. Then, attach your wires and solder everything. Your results may vary, depending on your soldering abilities and the materials with which you’re working. You can even use glue, as long as you don’t get glue between the metal contacts of the wires and pointer parts. It’s important that all the wires have a good, solid connection.

The last step is to mount the entire device in some sort of container to hold it all in place and to protect the guts of the machine from feline investigation. You can keep all the parts breadboarded, as long as it’s protected from the end user (your cat). I tend to use PVC pipes in cases like these because a standard servo fits almost perfectly in a two-inch I.D. PVC pipe. In this case, you can mount the lower servo to the edge of the pipe, and most of the wires and guts can be stowed securely inside of it, with a hole drilled in the side for the IR sensor. The Pi won’t fit, but it can be safely stowed away in a separate box, connected to the pipe assembly via long jumper wires. If you decide to go with a Pi Zero (which is completely capable of running this code), it will fit inside the pipe as well, so that may be something to consider.

Hopefully, you end up with a cat toy that looks something like Figure 9-11.

It’s not pretty, but your cat won’t care. It can be gussied up, of course, with a cap on the end of the pipe and a coat of paint. Probably the most important detail to remember (and it’s not shown here) is to hide the guts and wires from prying eyes (and paws). The PVC pipe I’ve used here is too narrow, but a pipe with a larger cross-section could easily be fitted with the Pi and all the other guts inside of it, making a self-contained unit. Then, you can add a power switch for the outside, and it’s ready to go.

That should be it! Executing the cat_toy.py script should now keep your feline friend (and quite possibly your human ones) entertained for hours. It’s worth noting that you now have the knowledge and capability to aim and fire a laser with your Raspberry Pi. Yes, it’s a measly little laser pointer, but the concept can easily be applied to any laser, regardless of size or power. Any laser.

Have fun!

Final Code

This code, available on the Apress.com website as cat-toy.py , sets up the GPIO output pins, seeds the random-number generators, and then spins the servos and lights the laser in random motions.

Summary

In this chapter, you successfully constructed a two-axis servo mechanism, hacked a laser pointer to be fired by the Raspberry Pi, and used your programming skills to randomly point and fire the laser to entertain your cat.

In the next chapter, we’re going to get your Pi out of the house and send it into the sky on a radio-controlled airplane.

A Shopping List of Parts

If you happen to already be an RC enthusiast, you’ll most likely have a plane you can use, but if you’re new to the sport, you’ll need to purchase a good starter plane. As an amateur myself, I can recommend a good beginner’s plane—the Switch, by Flyzone (shown in Figure 10-1).

This plane is sturdy enough to endure a few crashes while you learn to fly it, steady enough to be flown by an absolute beginner, and—most important—powerful enough to carry the extra weight of a Pi, GPS receiver, and battery to power them both. Its name comes from the fact that as you become more adept at flying, you can remove the wings from the steady “top” configuration and switch them to a lower, “mid” configuration for more aerobatic maneuvers. As you’ll see, the “top” configuration is perfect not just because it’s easy for beginners, but also because the Pi and GPS can sit comfortably atop the wing.

Ready? Let’s start by creating a directory for our plane program:

and then navigate into it by typing cd plane.

Now, let’s get the Pi to communicate with our GPS device.

Connecting the GPS Receiver to the Pi

To get your Pi to talk to the GPS receiver, you first need to connect the two. To do this, we’ll use the Python library called gpsd and the Pi’s UART (Universal Asynchronous Receiver/Transmitter) interface (pins 7 and 8). The Python gpsd module is part of a larger library of code designed to allow devices such as the Pi to monitor attached GPS and AIS receivers, with ports to C, C++, Java, and Python. It allows you to “read” the National Marine Electronics Association (NMEA) –formatted data transmitted by most GPS receivers.

The UART interface is an old one. It’s basically a serial (RS-232) connection, but for our purposes it’s all we need. It consists of a positive (+) and negative (-) connection for power, as well as transmit and receive pins. Start by typing the following line to install the software needed to read the GPS, gpsd, and its associated programs:

Next, we need to disable the default gpsd systemd service, as the one we installed should overwrite it. Do this with

Now, we need to disable the serial getty service:

We also need to force the Pi’s CPU to a fixed frequency and enable the UART interface. Ordinarily, the CPU’s frequency will vary according to the load, but this can unfortunately screw with sensitive items like GPS modules. This will slightly affect your Pi’s performance, but it’s unlikely you’ll notice much of a difference. To do this, edit the /boot/config.txt file:

and change the last line from

to

Now, reboot by typing

When the receiver’s LED starts to blink, you’ll know you have power. The GPS receiver we’re using has two blink rates. When it’s powered but has no GPS fix, it blinks once per second. When it has a fix, it blinks once per fifteen seconds.

When you have a fix, you can test your gpsd program. Enter

(to kill any running instances) and then

Then, start the generic GPS client by typing

The cgps client is a generic viewer; it simply takes the data the gpsd program is receiving and displays it to the user.

It may take a moment for data to begin to stream, but when it does, you should see a screen like the one in Figure 10-2.

If you see nothing but zeros, it means the GPS can’t find a satellite fix. You may have to wait a few minutes or even give the GPS a clear view of the sky. My experience is that this particular GPS board, even without the optional antenna, is very sensitive. When I added the antenna, I had no problem getting a GPS signal, even in my house. (Press “Q” to stop the stream and return to your terminal prompt.)

Once we know that the GPS unit is working and communicating with the Pi, we need to put that information into a format we can use in a log file. Although the generic client, cgps, that we used here is useful for viewing coordinates and testing our connections, unfortunately it’s really difficult to get usable information from it. For this reason, we’ll use the Python gps module to interact with the receiver.

Setting Up a Log File

When we get the stream from the GPS, we need to have a place to store it for later use, as it won’t do us much good if we’re just printing it to a (nonconnected) screen during the flight. What we can do is set up a log file using Python’s logging module, and then, when the Pi is back on the ground, we can parse the file and put it into a format we can use in Google Earth.

Setting up the log file is very simple. Start by typing

These two lines import the module, declare the log’s file name and what gets logged, and give the format of each line. We’ll save each GPS call in three strings: the longitude, latitude, and altitude—the three coordinates used by Google Earth. (They’re actually saved as floats, not strings, which means that we’ll have to convert them to strings when we write them to the log file.) To write a line to the log file, the format is simply this:

It is not necessary to use the newline (\n) character, because each time you call the logging.info() function, it begins on a new line.

In case you’re wondering, yes, we could simply write the GPS data to a regular file, but logging is an important, useful concept that many programmers either don’t fully understand or skip over completely. In the case of Python’s logging module, you can set log entries to be entered depending on the severity of the event being tracked. There are five severities possible: DEBUG, INFO, WARNING, ERROR, and CRITICAL.

To see the logging module in action, type python to start up a Python prompt and enter the following:

The second line will output

while the third line, classified as an INFO level, will not be sent to the console. If, on the other hand, you enter

it sets the default level to DEBUG, meaning that every event will be logged or outputted, regardless of severity. Entering the file name and format, as we did earlier, sets the log file and how events are written to it.

Formatting a KML File

A KML file is a special kind of XML (eXtensible Markup Language) used by Google Earth to delineate landmarks, objects, and even paths. It looks similar to an HTML file, with opening and closing < > tags for different levels of information, such as <Document> and </Document> and <coordinates> and </coordinates>. Once we have the log file from the GPS, we need to format the included coordinates in a KML file that Google Earth can recognize. Luckily, this is very easy, since we formatted the log file to just have longitude, latitude, and altitude, separated by spaces—with format='%(message)s' and the logging.info() line. Now, we can parse each line in the log file, separate it by spaces with string.split(), and write it into a preformatted .kml file. By using the write() function, we can write each line to the new file, called kml in the script, like so:

Since we know how the final KML file needs to look for Google Earth to use it, we can actually write a program that parses the file before our plane ever leaves the ground. That way, all we need to do is get the data to input from the actual log file, which we’ll get when the plane lands. The other parts of the file that don’t require actual coordinates can be formatted ahead of time.

For instance, every Google Earth–compatible KML file begins with the line

which is then followed by

and so on. So, we can write our script to add those lines to our final plane.kml file.

We’ll write our on-the-plane code to both take a picture and log the current GPS position every 30 seconds or so. Because we’re taking data points at specified times along a certain route, we can use KML’s path function to create a visual record of exactly what our plane did. The path will end up looking something like what you see in Figure 10-3.

Remember that because we’re only polling the GPS unit every 30 seconds , we won’t have a nice curved line. Instead, the path will connect the places where the plane was at those intervals, and the connections will be straight lines. As you can see in Figure 10-3, I used a parking lot for my test flights. My advice to a beginning flyer is to use a grassy field if you can, as crash landings in grass are likely to be easier on your plane! Everything in Alaska was covered by snow during my test flights, so it didn’t really matter where I tested things.

Using Threading and Objects

An important programming feature we’ll be using in this program is threads. You may have seen them before; I even use them in one or two of the other projects in this book. Threads are important because they allow your program and processor to do several tasks at once, and they don’t tie up all the memory and processing power doing one simple task. A simple call to import threading gives you the full power of threads and all they can do for you.

What we’ll do with them in this program is poll the GPS receiver. By using a thread, our main buffer won’t fill up with data as we continue to get data, yet we can still log the data in our log file for later use. To use threads in the most efficient way possible, we’ll create an object called a Poller that will request information from the GPS receiver every so often (let’s say every three seconds) using the gps module. Every time we get a position reading, we’ll update the log and take a picture.

Our thread object will be defined like so:

From the main portion of the program, we can start the thread by declaring a new myObject object (a new thread):

and then starting it with

The thread is now running with its own instance of the myObject, called newObject . Our thread (as shown in the final code at the end of the chapter) will be initiated with threading.Thread.__init__(self). Once it has been started, it will continue to execute its function (in our case, collecting GPS data and taking pictures) until we quit the program.

Setting Up Automatic Startup

Because it’s likely that we won’t have a monitor or keyboard plugged in when we power up the Pi before we strap it to the plane, we’ll need to make sure that our GPS logging script starts automatically. The easiest way to do that is to add an entry to the /etc/rc.local file (as explained in the sidebar “What Is the rc.local File?”). In our case, if our GPS logging code is called getGPS.py, and it’s stored in our Documents/plane folder, we can add the line

to the rc.local file. Open it with

and add the line

to the file before the last exit 0 line in the file.

However, that’s not all we need to do. Before the GPS program will even work, we need to turn on the GPS feed again, as we did when we were testing the generic GPS client (earlier in “Connecting the GPS Receiver to the Pi”). So, we also need to put that line into /etc/rc.local:

Finally, we need to wait for the GPS unit to get a fix on some satellites before we start logging; otherwise, we’ll be logging a whole lot of 0.0,0.0,nan coordinates. (The nan stands for not a number.) My experience is that it takes about 30 seconds for the unit to get a fix and start returning real data, so waiting 45 seconds before starting the script is probably safe. To do that, just put

after the sudo gpsd line you just added, and the system will wait 45 seconds before starting the Python script in the next line. When you’re done, your /etc/rc.local file should end like this:

Save and exit, and the script will now run on startup.

Connecting the Bits

Once you have the plane, building this project is relatively easy. You’ll need a battery for the Pi and a regulator to make sure you’re not giving it too much juice. I’m particularly fond of the Li-Po batteries (shown in Figure 10-4) that RC enthusiasts use because they’re light and pack a lot of power in a small package. The ones I use give me 1.3A for an hour—much longer than I need.

For the voltage regulator, you can purchase a 5V regulator from a distributor such as Adafruit or Sparkfun, or you can do what I did and hack a USB car charger, as seen in Figure 10-5.

The middle terminal goes to the battery’s (+) lead, and one of the outer terminals goes to GND. Then, a simple USB cable gets plugged into the Pi, and you have power.

When it comes to putting everything on the plane, it’s kind of a hodge-podge. The important details to remember are to keep the plane balanced and to not disrupt airflow over the wings. I put the GPS on the nose and taped the Pi to the wings. It’s kind of hard to see in the picture in Figure 10-6, but the camera is taped to the port wing, pointed at the ground. Just behind the wing you can see the USB plug that will be plugged into the Pi. The whole setup looks ungainly, but it flies pretty well.

Figure 10-7 shows how I attached the GPS unit to the nose of the plane .

Figure 10-8 shows how I attached the Pi to the plane’s wing.

When you’re ready to go and have done all your pre-flight checks, plug in the Pi and wait 45 seconds for the plane.py script to start and for the GPS unit to acquire some satellites. Then, take off and get some great pictures!

When you’re back home with the Pi, log in to it and run the .kml conversion script, called kml.py here. That script will open the locations.log file created by the plane.py script, parse its text, and write all of its included locations into a valid .kml file, called plane.kml .

You can then transfer that file to any computer with Google Earth installed. When it’s loaded onto your computer, right-click on the file and open the “Open With” menu. Find “Google Earth” in the program options and click “Open” (as shown in Figure 10-9).

When the file is loaded, you’ll get an image like the one of the parking lot in Figure 10-3 earlier in the chapter. The pictures taken by your camera, meanwhile, will be located in the same folder as your gpstest.py file or wherever you specify in your script. (See the final code at the end of this chapter for an example.)

Here’s a final hint: Because you put the gps script in your /etc/rc.local file, it will continue to start every time you power up until you remove that line from the file. If you want to kill the gps script so that it’s not running in the background and using processor resources, but you haven’t gotten around to deleting its line from rc.local, type

into a terminal. This command shows you all processes currently running on the Pi. To stop the Python script, look for a process titled “python” and note the PID (Process ID) in the first column. Press “Q” to quit top, and then type

where xxxx is the PID you noted earlier. That will kill the Python script until you remove its line from rc.local and reboot.

The Final Code

The final code consists of two parts: the plane program and the KML conversion program.

Summary

In this chapter, we connected a GPS to the Pi and read its input via the Pi’s UART connections. We then put that information into a Python log file. We strapped the Pi and the GPS to a radio-controlled airplane and logged our flight, taking pictures every few seconds as we flew. Then, after landing the plane, we transcoded our GPS log file to a KML file and put that file into Google Earth to see a satellite display of our final flight path. This chapter demonstrated the true portability of the Raspberry Pi.

In the next chapter, we’ll take the Pi even higher by sending it in a weather balloon to the upper atmosphere.

A Shopping List of Parts

Setting Up the GPS Receiver

As with the RC plane project in Chapter 10, an integral part of this project involves getting the GPS unit up and running with your Pi. To do this, you’re going to install the Python gpsd module and use the Pi’s Universal Asynchronous Receiver/Transmitter (UART) pins, #7 and #8. The Python gpsd module is part of a larger library of code designed to allow devices such as the Pi to monitor attached GPS and Automatic Identification System (AIS) receivers, with ports to C, C++, Java, and Python. It allows you to “read” the National Marine Electronics Association–formatted data transmitted by most GPS receivers.

The UART interface is an old one; it’s basically a serial (RS-232) connection, but for our purposes it’s all we need. It consists of a positive (+) and negative (–) connection for power, as well as transmit and receive pins. Start by typing the following line to install the software needed to read the GPS, gpsd, and its associated programs:

Next, we need to disable the default gpsd systemd service, as the one we installed should overwrite it. Do this with

Now, we need to disable the serial getty service:

We also need to force the Pi’s CPU to a fixed frequency and enable the UART interface. Ordinarily, the CPU’s frequency will vary according to the load, but this can unfortunately screw with sensitive items like GPS modules. This will slightly affect your Pi’s performance, but it’s unlikely you’ll notice much of a difference. To do this, edit the /boot/config.txt file:

and change the last line from

to

Now, reboot by typing

When the receiver’s LED starts to blink, you’ll know you have power. The GPS receiver we’re using has two blink rates. When it’s powered but has no GPS fix, it blinks once per second. When it has a fix, it blinks once per fifteen seconds.

When you have a fix, you can test your gpsd program. Enter

(to kill any running instances) and then

Then, start the generic GPS client by typing

The cgps client is a generic viewer; it simply takes the data the gpsd program is receiving and displays it to the user.

It may take a moment for data to begin to stream, but when it does, you should see a screen like the one in Figure 11-1.

We won’t be using the cgps display—it’s just a handy way of making sure the GPS unit is hooked up correctly and is working. We’ll instead use Python’s gps module to communicate with the GPS board.

Storing the GPS Data

For this project, you’ll be writing the GPS data into a file to be read, recorded, and transmitted later. We could use a logging file for this, as we did for the RC plane project, but it’s also important that you learn to use Python to read from and write to normal files. In your terminal, start a Python prompt and type

To continue, type

If you now exit your Python prompt by pressing Ctrl+d and list your directory contents, you’ll see testfile.txt listed, and viewing its contents will show you the line you just entered. Now, try it again: start another Python prompt and type

and exit your Python prompt. Because you opened the file using a 'w' parameter, all the original text was overwritten. This is what you’ll be doing in our GPS location file. We’re not interested in saving the locations as we did before in the plane’s log file; rather, each location will be recorded and then transmitted, and then we can overwrite it with the next location by opening it with the 'w' flag.

Installing PiFM

To get your Pi to talk to you over the radio, you’ll need to use a handy little hack developed by the members of the Imperial College Robotics Society in London. The module, called PiFM , uses the Pi’s existing hardware to turn it into a nice little FM transmitter.

To use the module, you’ll first have to download it. In your /balloon directory, open a terminal and type

When it’s done downloading, extract it by typing

This will place a compiled binary, as well as the source code and a few sound files, in your directory. You’re now ready to use the PiFM package. To try it out, attach a foot-long wire to your Pi’s pin #7 (GPIO pin #4). Now, in your terminal, type

and tune your radio to 100.0 FM. You should be rewarded with a familiar tune. If by chance you don’t hear anything, try adding ‘22050’ to the end of the command, as that extra parameter (the sample rate of the sound file) may need to be stated explicitly, depending on the version of software you have.

Congratulations! You’ve turned your Pi into a radio transmitter. Now, let’s make it a DJ.

Installing Festival

I’m pretty sure most of us would love it if our computers would talk to us. Luckily, since we’re using Linux, we have a few options when it comes to a good speech synthesizer program. The one we’ll be using, Festival, is free and very easy to use. It also comes with a handy text-to-speech recording function that we’ll be using.

Festival is available from your standard Pi repositories, which means that to use it, you only need to type

in your terminal, and it will download and install. Once the download and installation process is complete, try it out. Plug a pair of headphones into your Pi’s 3.5mm audio out jack. Then, in your terminal, type the following:

and your Pi will proceed to speak to you. (In case you don’t know, that line is spoken by the computer, HAL, in the classic movie 2001: A Space Odyssey . If you haven’t seen it, put this book down and go watch it. Now. I’ll wait.)

Okay, so now you can make your Pi speak whatever line you tell it to in the command line. While that’s pretty cool, we need to have it read a line from a text file: something like “Current altitude 10,000 feet, current position 92 degrees latitude, 164 degrees longitude.” The easiest way to do that is to use Festival’s very handy text2wave function. This function reads from a file—position.txt, for example—and makes a recording of it. Its syntax is

Now, knowing that we’ll be updating the position.txt file every 15 seconds, we can just use the text2wave function to re-record its contents before broadcasting that recording using PiFM.

There’s one small snag, however: text2wave encodes its recordings using a sample rate of 44100 kHz, and PiFM needs a recording with a sample rate of 22050 kHz. This requires another program for our toolkit—FFMPEG.

Installing FFMPEG

In the world of audio and video encoders, decoders, and transcoders, FFMPEG is definitely one of the most popular and powerful programs available. It can transcode movie files from MPG to AVI format, separate an AVI file into its individual frames, and even separate the audio from a film, run it through successive filters, and re-attach it to the video.

However, while all those feats are impressive, all we need to use it for is to change our audio from 44100 kHz to 22050 kHz. Start by grabbing the source file with

When it’s finished downloading, extract it to its own directory with

When it’s finished extracting, cd into the resulting directory with

and then type

to configure the installation. When that’s done, enter

and then

to install the ffmpeg library. It’s not a small library, so feel free to grab a cup of coffee or a nap while it compiles.

Preparing the Pi

If you’re reading this chapter after the RC plane chapter, you may recognize much of the setup here, as many of the parts of these projects are very similar. The first thing you need to do is to make sure that the gpsd module will be running every time you start the Pi. To do that, open your rc.local file by typing

and add the following line to the end:

Now the gpsd module will run every time we start the Pi.

However, we’re not done in the rc.local file. It’s likely that when you launch the balloon, you’ll want to just power the Pi and launch, without having to worry about logging in and starting up the program you’ve written. Luckily, you can do that with the rc.local file too. Upon startup, after the gpsd module launches, you’ll want to give your GPS board a few seconds to get a fix on some satellites before it starts logging data. To do that, after the gpsd line just shown, add the line

to make the Pi pause for 45 seconds, and then add the line

(Make sure this line matches wherever you’re storing your balloon program, of course.) Your balloon program will now start automatically, 45 seconds after your GPS module begins to read data from its satellite fixes.

Using Threading and Objects

An important programming feature we’ll be using in this project is threads. If you already built the RC plane project in Chapter 10, this will be old hat to you. If you haven’t, however, here’s a quick rundown.

Threads are important because they allow your program and processor to do several tasks at once, and they don’t tie up all the memory and processing power doing one simple task. A simple call to import threading gives you the full power of threads and all they can do for you.

What do threads actually do? Threads allow your computer to (seemingly) execute several tasks at once. I say “seemingly” because the processor can still execute only one process at a time, but threads allow it to switch back and forth between processes so fast it seems to be executing them simultaneously. For more of an introduction to threads, see the sidebar in Chapter 10.

We’ll use them to poll the GPS receiver. By using a thread, our main buffer won’t fill up with data as we continue to get data, and we can still log the data in our position.txt file for later use. To use threads in the most efficient way possible, we’ll create an object called a Poller that will request information from the GPS receiver every 15 seconds using the gps module. Every time we get a position reading, we’ll update the text file and take a picture.