Raspberry Pi cookbook for Python programmers

The Raspberry Pi is a single-board computer created by the Raspberry Pi Foundation, a charity formed with the primary purpose of reintroducing low-level computer skills to children in the UK. The aim was to rekindle the microcomputer revolution from the 1980s, which produced a whole generation of skilled programmers.

Even before the computer was released at the end of February 2012, it was clear that the Raspberry Pi had gained a huge following worldwide and has now sold over 2 million units. The following image represents a Raspberry Pi Model B:

A Raspberry Pi Model B (revision 2.0)

The name, Raspberry Pi, was the combination of the desire to create an alternative fruit-based computer (such as Apple, BlackBerry, and Apricot) and a nod to the original concept of a simple computer that can be programmed using Python (shortened to Pi).

Within this book, we will take this little computer, find out how to set it up, and then explore its capabilities chapter by chapter using the Python programming language.

It is often asked, "Why has Python been selected as the language to use on the Raspberry Pi?". The fact is that Python is just one of the many programming languages that can be used on the Raspberry Pi.

There are many programming languages that you can choose, from high-level graphical block programming, such as Scratch, to traditional C, right down to BASIC, and even raw Machine Code Assembler. A good programmer often has to be code multilingual to be able to play to the strengths and weaknesses of each language in order to best meet the needs of their desired application. It is useful to understand how different languages (and programming techniques) try to overcome the challenge of converting "what you want" into "what you get" as this is what you are trying to do as well while you program.

Python has been selected as a good place to start when learning about programming by providing a rich set of coding tools while still allowing simple programs to be written without fuss. This allows beginners to gradually be introduced to the concepts and methods on which modern programming languages are based without requiring them to know it all from the start. It is very modular with lots of additional libraries that can be imported to quickly extend the functionality. You will find that over time, this encourages you to do the same, and you will want to create your own modules that you can plug in to your own programs, thus taking your first steps into structured programming.

Like all programming languages, Python isn't perfect; things such as adding a space at the start of a line will often break your code (indents matter a lot in Python; they define how blocks of code are grouped together). Generally, Python is slow; since it is interpreted, it takes time to create a module while it is running the program. This can be a problem if you need to respond to time critical events. However, you can precompile Python or use modules written in other languages to overcome this. It hides the detail; this is both an advantage and disadvantage. It is excellent for beginners but can be difficult when you have to second-guess aspects such as data-types, but this in turn forces you to consider all the possibilities, which can be a good thing.

A massive source of confusion for beginners is that there are two versions of Python on the Raspberry Pi (Version 2.7 and Version 3.2), which are not compatible with one another, so code written for Python 2.7 may not run with Python 3.2 (and vice versa).

The Python Software Foundation is continuously working to improve and move forward with the language, which sometimes means they have to sacrifice backward compatibility in order to embrace new improvements (and importantly, remove redundant and legacy ways of doing things).

Essentially, the selection of which version to use will depend on what you intend to do. For instance, you may require Python 2.7 libraries, which are not yet available for Python 3.2. Python 3 has been available since 2008, so these tend to be older or larger libraries that have not been translated. In many cases, there are new alternatives to legacy libraries; however, their support can vary.

In this book, we have used Python 3.2, which is also compatible with Python 3.3.

Before you can use your Raspberry Pi, you will need an SD card with an operating system installed or with the New Out Of Box System (NOOBS) on it, as discussed in the Using NOOBS to set up your Raspberry Pi SD card recipe.

The following section will detail the types of devices you can connect to the Raspberry Pi and importantly, how and where to plug them in.

As you will discover later, once you have your Raspberry Pi set up, you may decide to connect remotely and use it through a network link, in which case you only need power and a network connection. Refer to the following sections: Connecting remotely to the Raspberry Pi over the network using VNC and Connecting remotely to the Raspberry Pi over the network using SSH (and X11 Forwarding).

The layout of the Raspberry Pi is shown in the following figure:

The Raspberry Pi connection layout (Model B revision 2.0)

The description of the preceding figure is explained as follows:

You should aim to make all other connections to the Raspberry Pi before connecting the power. However, USB devices, audio, and network may be connected and removed while it is running without problems.

In addition to the standard primary connections you would expect to see on a computer, the Raspberry Pi also has a number of additional connections.

Since NOOBS creates a RECOVERY Partition to keep the original installation images, a 4 GB SD card or larger is recommended. You will also need an SD card reader (experience has shown that some built-in card readers can cause issues, so an external USB type reader is recommended).

If you are using an SD card that you have used previously, you may need to reformat it to remove any previous partitions and data. NOOBS expects the SD card to consist of a single FAT32 partition. If using Windows or Mac OS X, you can use SD association's formatter, as shown in the following screenshot (available at https://www.sdcard.org/downloads/formatter_4/):

Get rid of any partitions on the SD card using SD formatter

From the Option Setting dialog box, set Format Size Adjustment. This will remove all the SD card partitions that were created previously.

If using Linux, you can use gparted to clear any previous partitions and reformat it as a FAT32 partition.

The full NOOBS package (typically around 1.3 GB) contains a selection of the most popular Raspberry Pi operating system's images built in. A lite version of NOOBS is also available that has no preloaded operating systems (although, a smaller initial download of 20 MB and a wired network connection on the Raspberry Pi is required to directly download the operating system you intend to use).

NOOBS is available at http://www.raspberrypi.org/downloads with the documentation available at https://github.com/raspberrypi/noobs.

By performing the following steps, we will prepare the SD card to run NOOBS. This will then allow us to select and install the operating system we want to use:

By default, NOOBS will display via the HDMI connection. If you have another type of screen (or you don't see anything), you will need to manually select the output type by pressing 1, 2, 3, or 4 according to the following functions:

This display setting will also be set for the installed operating system.

After a short while, you will see the NOOBS selection screen that lists the available distributions that have been included. There are many more distributions that are available, but these are the ones the Raspberry Pi Foundation has selected for the NOOBS system. Click on Raspbian as this is the operating system being used in this book.

Press Enter or click on Install OS, and confirm that we wish to overwrite all the data on the card. This will overwrite any distributions previously installed using NOOBS but will not remove the NOOBS system; you can return to it at any time by pressing Shift when you turn the power on.

It will take around 10 to 30 minutes to write the data to the card depending on its speed. When it completes and the Image Applied Successfully message appears, click on OK and the Raspberry Pi will start to boot into raspi-config.

The purpose of writing the image file to the SD card in this manner is to ensure that the SD card is formatted with the expected filesystem partitions and files required to correctly boot the operating system.

When the Raspberry Pi powers up, it loads some special code contained within the GPU's internal memory (commonly referred to as the binary blob by the Raspberry Pi Foundation). The binary blob provides the instructions required to read the BOOT Partition on the SD card, which (in the case of a NOOBS install) will load NOOBS from the RECOVERY partition. If, at this point, Shift is pressed, NOOBS will load the recovery and installation menu. Otherwise, NOOBS will begin loading the OS as specified by the preferences stored in the SETTINGS Partition.

When loading the operating system, it will boot via the BOOT partition using the settings defined in config.txt and options in cmdline.txt to finally load to the terminal or desktop on the root Partition, depending on what you have set up in raspi-config. Refer to the following diagram:

NOOBS creates several partitions on the SD card to allow installation of multiple operating systems and to provide recovery

NOOBS allows the user to optionally install multiple operating systems on the same card and provides a boot menu to select between them (with an option to set a default value in the event of a time-out period).

You can also choose to create an optional data Partition that allows you to keep your datafiles separate to the operating system. This makes it easier to share files between multiple systems and allows you to keep backups of just your user data.

If you later add, remove, or reinstall an operating system, ensure that you make a copy of any files, including system settings you wish to keep first as NOOBS may overwrite everything on the SD card.

When you power up the Raspberry Pi for the first time, it will start directly into raspi-config (this only occurs for the first boot of a new install), which will allow you to perform changes to your SD card and set up your general preferences. Use the sudo raspi-config command to run it another time. When you exit this program, it will load directly by default to the terminal interface, which is the command line of the Raspberry Pi. To start a desktop session, such as Windows or OS X, use the startx command, which will load the Raspbian desktop.

Changing the default user password

Ensure that you change the default password for the pi user account once you have logged in as the default password is well known. This is particularly important if you connect to the public networks. You can do this with the passwd command, as shown in the following screenshot:

Setting a new password for the pi user

This gives greater confidence because if you later connect to another network, only you will be able to access your files and take control of your Raspberry Pi.

sudo shutdown –h now

sudo reboot

Preparing an SD card manually

An alternative to using NOOBS is to manually write the operating system image to the SD card. While this was originally the only way to install the operating system, some users still prefer it. It allows the SD cards to be prepared before they are used in the Raspberry Pi. It can also provide easier access to startup and configuration files (refer to the Networking directly to a laptop or computer recipe), and it leaves more space available for the user (unlike NOOBS, a RECOVERY partition isn't included).

The default Raspbian image actually consists of two partitions, BOOT and SYSTEM, which will fit onto a 2 GB SD card (4 GB or more is recommended).

You need a computer running Windows/Mac OS X/Linux (although it is possible to use another Raspberry Pi to write your card, be prepared for a very long wait).

Download the latest version of the operating system you wish to use. For the purpose of this book, it is assumed you are using the latest version of Raspbian available at http://www.raspberrypi.org/downloads.

Perform the following steps depending on the type of computer you plan to use to write to the SD card (the .img file you need is usually compressed, so before you start, you will need to extract the file).

The following steps are for Windows:

1. Ensure that you have downloaded the Raspbian image, as previously detailed, and extracted it to a convenient folder to obtain a .img file.

2. Obtain the Win32DiskImager.exe file available at http://www.sourceforge.net/projects/win32diskimager.

3. Run Win32DiskImager.exe from your downloaded location.

4. Click on the folder icon and navigate to the location of the .img file and click on Save.

5. If you haven't already done so, insert your SD card into your card reader and plug it into your computer.

6. Select the Device drive letter that corresponds to your SD card from the small drop-down box. Ensure you double-check this is the correct device (as the program will overwrite whatever is on the device when you write the image).

   Note

   The drive letter may not be listed until you select a source image file.

7. Finally, click on the Write button and wait for the program to write the image to the SD card.

8. Once completed, you can exit the program. Your SD card is ready! Refer to the following screenshot:

Manually write operating system images to the SD card using Disk Imager

The following steps should work for the most common Linux distributions, such as Ubuntu and Debian:

1. Using your preferred web browser, download the Raspbian image and save it somewhere suitable.

2. Extract the file from the file manager or locate the folder in the terminal and unzip the .img file with the following command:

   unzip filename.zip
   

3. If you haven't already done so, insert your SD card into your card reader and plug it into your computer.

4. Use the df –h command and identify the sdX identifier for the SD card. Each partition will be displayed as sdX1, sdX2, and so on, where X will be a, b, c, d, and so on for the device ID.

5. Ensure that all the partitions on the SD card are unmounted using the umount /dev/sdXn command for each partition, where sdXn is the partition being unmounted.

6. Write the image file to the SD card with the following command:

   sudo dd if=filename.img of=/dev/sdX bs=4M
   

7. The process will take some time to write to the SD card, returning to the terminal prompt when complete.

8. Unmount the SD card before removing it from the computer using the following command:

   umount /dev/sdX1
   

The following steps should work for most of the versions of OS X:

1. Using your preferred web browser, download the Raspbian image and save it somewhere suitable.

2. Extract the file from the file manager or locate the folder in the terminal and unzip the .img file with the following command:

   unzip filename.zip
   

3. If you haven't already done so, insert your SD card into your card reader and plug it into your computer.

4. Use the diskutil list command and identify the disk# identifier for the SD card. Each partition will be displayed as disk#s1, disk#s2, and so on, where # will be 1, 2, 3, 4 and so on for the device ID.

   Note

   If rdisk# is listed, use this for faster writing (this is a raw path and skips data buffering).

5. Ensure that the SD card is unmounted using the unmountdisk /dev/diskX command, where diskX is the device being unmounted.

6. Write the image file to the SD card with following command:

   sudo dd if=filename.img of=/dev/diskX bs=1M
   

7. The process will take some time to write to the SD card, returning to the terminal prompt when complete.

8. Unmount the SD card before removing it from the computer using the following command:

   unmountdisk /dev/diskX
   

Refer to the following screenshot:

The boot process of a manually installed OS image

Expanding the system to fit in your SD card

A manually written image will be of a fixed size (usually made to fit the smallest sized SD card possible). To make full use of the SD card, you will need to expand the system partition to fill the remainder of the SD card. This can be achieved using the raspi-config tool.

Start the raspi-config tool with the following command:

sudo raspi-config

Select the menu item, 1 Expand Filesystem Ensures that all of the SD card storage is available to the OS, as shown in the following screenshot:.

The raspi-config menu

Accessing the Data/RECOVERY/BOOT partition

Windows and Mac OS X do not support the ext4 format, so when you read the SD card, only the File Allocation Table (FAT) partitions will be accessible. In addition, Windows only supports the first partition on an SD card, so if you've installed NOOBS, only the RECOVERY partition will be visible. If you've written your card manually, you will be able to access the BOOT partition.

The data partition (if you installed one via NOOBS) and the root partition are in ext4 format and won't usually be visible on non-Linux systems.

Note

If you do need to read files from the SD card using Windows, a freeware program, Linux Reader (available at www.diskinternals.com/linux-reader) can provide a read-only access to all of the partitions on the SD card.

Access the partitions from the Raspberry Pi. To view the currently mounted partitions, use df, as shown in the following screenshot:

The result of the df command

To access the BOOT partition from within Raspbian, use the following command:

cd /boot/

To access the RECOVERY or data partition, we have to mount it, by performing the following steps:

1. Determine the name of the partition as the system refers to it by listing all the partitions, even the unmounted ones. The sudo fdisk -l command lists the partitions, as show in the following screenshot:

   

   The partition table of a NOOBS install of Raspbian and data partition

   mmcblk0p1	(vfat) RECOVERY
   mmcblk0p2	(Extended partition) contains (root, data, BOOT)
   mmcblk0p3	(ext4) root
   mmcblk0p5	(ext4) data
   mmcblk0p6	(vfat) BOOT
   mmcblk0p7	(ext4) SETTINGS

   If you have installed additional operating systems on the same card, the partition identifiers shown in the preceding table will be different.

2. Create a folder and set it as the mount point for the partition as follows:

   • For the RECOVERY partition, use the following command:

     mkdir ~/recovery
     sudo mount –t vfat /dev/mmcblk0p1 ~/recovery
     

   • For the data partition, use the following command:

     mkdir ~/userdata
     sudo mount –t ext4 /dev/mmcblk0p5 ~/userdata
     

To ensure they are mounted each time the system is started, perform the following steps:

1. Add the sudo mount commands to /etc/rc.local before exit 0. If you have a different username, you will need to change pi to match.

   sudo nano /etc/rc.local
   sudo mount -t vfat /dev/mmcbblk0p1 /home/pi/recovery
   sudo mount -t ext4 /dev/mmcbblk0p5 /home/pi/userdata
   

2. Save and exit by pressing Ctrl + X, Y, and Enter.

Note

Commands added to /etc/rc.local will be run for any user who logs onto the Raspberry Pi. If you only want the drive to be mounted for the current user, the commands can be added to .bash_profile instead.

If you have install additional operating systems on the same card, the partition identifiers shown here will be different.

You will need an access to a suitable wired network, which will be connected to the Internet and a standard network cable (Cat5e or a similar one with a RJ45 type connector for connecting to the Raspberry Pi).

Many networks connect and configure themselves automatically using Dynamic Host Configuration Protocol (DHCP), which is controlled by the router or switch. If this is the case, simply plug the network cable into a spare network port on your router or network switch (or wall network socket if applicable).

Alternatively, if a DHCP server is not available, you shall have to configure the settings manually (refer to the There's more… section for details).

You can confirm this is functioning successfully with the following steps:

If the above tests fail, you will need to check your connections and then confirm the correct configuration for your network.

If you find yourself using your Raspberry Pi regularly on the network and if you need to find out the IP address, you may find it helpful to fix the IP address to a known value by manually setting the IP address. However, remember to switch it back to use DHCP when connecting on another network.

Some routers will also have an option to set a Static IP DHCP address, so the same address is always given to the Raspberry Pi (how this is set will vary on the router itself).

Knowing your Raspberry Pi's IP address when it is on the network is particularly useful if you intend to use one of the remote access solutions described later on, which avoids the need for a display.

On some networks, you may be able to use the Raspberry Pi's hostname instead of its IP address (the default is raspberrypi), but not all networks will support this without additional software such as Bonjour (built in to OS X and available for Windows).

Before you start, you will need to determine the network settings for your network.

You will need to find out the following information from your router's settings or another computer connected to the network:

For Windows, you can obtain this information by connecting to the Internet and running the following command:

ipconfig /all

Locate the active connection (usually called Local Area Connection 1 or similar if you are using a wired connection or if you are using Wi-Fi, it is called wireless network connection) and find the information required as follows:

The ipconfig/all command shows useful information about your network settings

For Linux and Mac OS X, you can obtain the required information with the following command (note that it is ifconfig rather than ipconfig):

ifconfig

The DNS servers are called nameservers and are usually listed in the resolv.conf file. You can use the less command as follows to view its contents (press Q to quit when you have finished viewing it):

less /etc/resolv.conf

To set the network interface settings, edit /etc/network/interfaces using the following code:

sudo nano /etc/network/interfaces

Now, perform the following steps:

You can configure the network settings by editing cmdline.txt in the BOOT partition and adding settings to the startup command line with ip.

The ip option takes the following form:

ip=client-ip:nfsserver-ip:gw-ip:netmask:hostname:device:autoconf

You will need the Raspberry Pi with power and a standard network cable.

It may also be helpful to have a keyboard and monitor available to perform additional testing, particularly, if this is the first time you have tried this.

To ensure that you can restore your network settings back to their original values, you should check whether it has a fixed IP address or the network is configured automatically.

To check the network settings on Windows 7 and Vista, perform the following steps:

To check the network settings on Linux, perform the following steps:

To check the network settings on Mac OS X, perform the following steps:

OS X Network Settings dialog box

If you just need to access or control the Raspberry Pi without an Internet connection, refer to the Direct network link section on the There's more…section.

First, we need to enable ICS on our network devices. In this case, we will be sharing the Internet, which is available on Wireless Network Connection through Local Area Connection to the Raspberry Pi.

For Windows, perform the following steps:

For Mac OS X to enable the ICS, perform the following steps:

For Linux to enable the ICS, perform the following steps:

The IP address of the network adapter will be the Gateway IP address to be used on the Raspberry Pi, and we must also provide the Raspberry Pi with an IP address that matches the IP address (except the last number). For instance, if the computer's wired connection now has 192.168.137.1, we can set the Raspberry Pi's IP address to 192.168.137.10 and set the Gateway IP to 192.168.137.1.

Next, we will set the required settings on the Raspberry Pi. We need to edit the cmdline.txt file, which we can do directly on the Raspberry Pi or on the computer (this is useful if there isn't a monitor or keyboard attached to the Raspberry Pi).

To edit directly on the Raspberry Pi, perform the following steps:

To edit on another computer, perform the following steps:

The file will contain something similar to the following command line (all on a single line):

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

To set the Raspberry Pi's IP address (for example, 192.168.137.10) and the Gateway IP address (for example, 192.168.137.1) when it next powers up, we add the following command line to the end of the same line using ip= option:

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait ip=192.168.137.10::192.168.137.1

We are now ready to test the new connection as follows:

Hopefully, you will find you have a working connection and receive replies from the Raspberry Pi.

If you have a keyboard and screen connected to the Raspberry Pi, you can perform the following steps:

If all goes well, you will have full Internet available through your computer to the Raspberry Pi, allowing you to browse the web as well as update and install new software.

If the connection fails, perform the following steps:

Just remember that this address may be different on different networks and computers, so if you have problems, confirm that the IP address has not changed on the shared adapter.

When we enable ICS on the primary computer, the operating system will automatically allocate a new IP address to the computer. Once we determine what the new IP address is, we can ensure that the Raspberry Pi is set to a compatible IP address and the primary computer IP address is used as the Gateway IP address.

Finally, we check whether the computer can communicate over the direct network link to the Raspberry Pi, back the other way, and also through to the Internet.

If you do not require the Internet on the Raspberry Pi, or your computer only has a single network adapter, we can still connect the computers together through a direct network link. The advantage of this method is that the same IP address should work on most of the computers as long as the adapter you connect to is set to automatic. Refer to the following diagram:

Connecting and using the Raspberry Pi with just a network cable, a standard imaged SD card, and power

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait ip=169.254.1.10

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait ip=192.168.1.10

If you don't have a keyboard or screen connected to the Raspberry Pi, you can use this network link to remotely access the Raspberry Pi just as you would on a normal network (just use the new IP address you have set for the connection). Refer to the Connecting remotely to the Raspberry Pi over the network using VNC and Connecting remotely to the Raspberry Pi over the network using SSH (and X11 Forwarding) recipes.

You shall need to obtain a suitable USB Wi-Fi dongle; and in some cases, you may require a powered USB hub (this will depend on the hardware version of the Raspberry Pi you have and the quality of your power supply). General suitability of USB Wi-Fi dongles will vary depending on the chipset that is used inside and the level of Linux support available. You may find that some USB Wi-Fi dongles will work without installing additional drivers (in which case you can jump to configuring it for the wireless network)

A list of supported Wi-Fi adapters is available at http://elinux.org/RPi_VerifiedPeripherals#USB_WiFi_Adapters.

You will need to ensure that your Wi-Fi adapter is also compatible with your intended network; for example, supporting the same types of signals 802.11bgn and the encryptions WEP, WPA, and WPA2 (although most networks are backward compatible).

You will also need the following details of your network:

You will require a working Internet connection (that is, wired Ethernet) in order to download the required drivers. Otherwise, you may be able to locate the required firmware files (they will be the .deb files), and copy them to the Raspberry Pi (that is, via a USB flash drive; the drive should be automatically mounted if you are running in the desktop mode). Copy the file to a suitable location and install it with the following command:

sudo apt-get install firmware_file.deb

This task has two stages; first, we would identify and install firmware for the Wi-Fi adapter, and then we would need to configure it for the wireless network.

We will try to identify the chipset of your Wi-Fi adapter (the part that handles the connection); this may not match the actual manufacturer of the device.

An approximate list of supported firmware can be found with the following command:

sudo apt-cache search wireless firmware

This will produce results similar to the following output (disregarding any results without firmware in the package title):

atmel-firmware - Firmware for Atmel at76c50x wireless networking chips.
firmware-atheros - Binary firmware for Atheros wireless cards
firmware-brcm80211 - Binary firmware for Broadcom 802.11 wireless cards
firmware-ipw2x00 - Binary firmware for Intel Pro Wireless 2100, 2200 and 2915
firmware-iwlwifi - Binary firmware for Intel PRO/Wireless 3945 and 802.11n cards
firmware-libertas - Binary firmware for Marvell Libertas 8xxx wireless cards
firmware-ralink - Binary firmware for Ralink wireless cards
firmware-realtek - Binary firmware for Realtek wired and wireless network adapters
libertas-firmware - Firmware for Marvell's libertas wireless chip series (dummy package)
zd1211-firmware - Firmware images for the zd1211rw wireless driver

To find out the chipset of your wireless adapter, plug the Wi-Fi-adapter into Raspberry Pi, and from the terminal, run the following command:

dmesg | grep 'Product:\|Manufacturer:'

This should return something similar to the following output (in this case, I've got a ZyXEL device, which has a ZyDAS chipset (a quick Google search reveals zd1211-firmware is for ZyDAS devices):

[    1.893367] usb usb1: Product: DWC OTG Controller
[    1.900217] usb usb1: Manufacturer: Linux 3.6.11+ dwc_otg_hcd
[    3.348259] usb 1-1.2: Product: ZyXEL G-202
[    3.355062] usb 1-1.2: Manufacturer: ZyDAS

Once you have identified your device and the correct firmware, you can install it, as you would for any other package available through apt-get (where zd1211-firmware can be replaced with your required firmware as) shown in the following command:

sudo apt-get install zd1211-firmware

Remove and reinsert the USB Wi-Fi dongle to allow it to be detected and the drivers loaded. We can now test if the new adapter is correctly installed with ifconfig. The output is shown as follows:

wlan0     IEEE 802.11bg  ESSID:off/any
          Mode:Managed  Access Point: Not-Associated   Tx-Power=20 dBm
          Retry  long limit:7   RTS thr:off   Fragment thr:off
          Power Management:off

The command will show the network adapters present on the system. For Wi-Fi, this is usually as wlan0, or wlan1, or so on if you have installed more than one. If not, double-check the selected firmware; and perhaps, try an alternative or check on the site for troubleshooting tips.

Once we have the firmware installed for the Wi-Fi adapter, we will need to configure it for the network we wish to connect. Perform the following steps:

The Model A version of the Raspberry Pi does not have a built-in network port; so in order to get a network connection, a USB network adapter will have to be added (either a Wi-Fi dongle, as explained in the preceding section, or a LAN-to-USB adapter, as described in the following section.

sudo apt-get install firmware_file.deb

You will need the address of the proxy server you are trying to connect to, including the username and password if one is required.

You should confirm that the Raspberry Pi is already connected to the network and that you can access the proxy server.

Use the ping command to check this as follows:

ping proxy.address.com -c 4

If this fails (you get no responses), you will need to ensure your network settings are correct before continuing.

Create a new file using nano as follows (if there is content in the file already, you can add the code at the end):

sudo nano -c ~/.bash_profile

To allow the basic web browsing through programs such as midori while using a proxy server, you can use the following script:

function proxyenable {
# Define proxy settings
PROXY_ADDR="proxy.address.com:port"
# Login name (leave blank if not required):
LOGIN_USER="login_name"
# Login Password (leave blank to prompt):
LOGIN_PWD=
#If login specified - check for password
if [[ -z $LOGIN_USER ]]; then
  #No login for proxy
  PROXY_FULL=$PROXY_ADDR
else
  #Login needed for proxy Prompt for password -s option hides input
  if [[ -z $LOGIN_PWD ]]; then
    read -s -p "Provide proxy password (then Enter):" LOGIN_PWD
    echo
  fi
  PROXY_FULL=$LOGIN_USER:$LOGIN_PWD@$PROXY_ADDR
fi
#Web Proxy Enable: http_proxy or HTTP_PROXY environment variables
export http_proxy="http://$PROXY_FULL/"
export HTTP_PROXY=$http_proxy
export https_proxy="https://$PROXY_FULL/"
export HTTPS_PROXY=$https_proxy
export ftp_proxy="ftp://$PROXY_FULL/"
export FTP_PROXY=$ftp_proxy
#Set proxy for apt-get
sudo cat <<EOF | sudo tee /etc/apt/apt.conf.d/80proxy > /dev/null
Acquire::http::proxy "http://$PROXY_FULL/";
Acquire::ftp::proxy "ftp://$PROXY_FULL/";
Acquire::https::proxy "https://$PROXY_FULL/";
EOF
#Remove info no longer needed from environment
unset LOGIN_USER LOGIN_PWD PROXY_ADDR PROXY_FULL
echo Proxy Enabled
}

function proxydisable {
#Disable proxy values, apt-get and git settings
unset http_proxy HTTP_PROXY https_proxy HTTPS_PROXY
unset ftp_proxy FTP_PROXY
sudo rm /etc/apt/apt.conf.d/80proxy
echo Proxy Disabled
}

Once done, save and exit by pressing Ctrl + X, Y, and Enter.

Many programs that make use of the Internet will check for the http_proxy or HTTP_PROXY environment variables before connecting. If they are present, they will use the proxy settings to connect through. Some programs may also use the HTTPS and FTP protocols, so we can set the proxy setting for them here too.

The last part allows any programs that execute using the sudo command to use the proxy environment variables while acting as the super user (most programs will try accessing the network using normal privileges first, even if running as a super user, so it isn't always needed).

We also need to allow the proxy settings to be used by some programs, which use super user permissions while accessing the network (this will depend on the program; most don't need this). We need to add the commands into a file stored in /etc/sudoers.d/ by performing the following steps:

Ensure that your Raspberry Pi is powered up and connected to the Internet. We will use the Internet connection to install a program using apt-get. This is a program that allows us to find and install applications directly from the official repositories.

First, we need to install the TightVNC server on the Raspberry Pi with the following commands. It is advisable to run an update command first to get the latest version of the package you want to install as follows:

sudo apt-get update
sudo apt-get install tightvncserver

Accept the prompt to install and wait until it completes. To start a session, use the following command to start a session:

vncserver :1

The first time you run this, it will ask you to enter a password (of no more than eight characters) to access the desktop (you will use this when you connect from your computer).

The following message should confirm that a new desktop session has been started:

New 'X' desktop is raspberrypi:1

If you do not already know the IP address of the Raspberry Pi, use hostname –I and take note of it.

Next, we need to run a VNC client, VNC Viewer is suitable program, which is available at http://www.realvnc.com/ and should work on Windows, Linux, and OS X.

When you run VNC Viewer, you will be prompted for the Server address and Encryption type. Use the IP address of your Raspberry Pi with :1. That is, for the IP address 192.168.1.69, use the 192.168.1.69:1 address.

You can leave the Encryption type as Off or Automatic.

Depending on your network, you may be able to use the hostname; the default is raspberrypi, that is raspberrypi:1.

You may have a warning about not having connected to the computer before or having no encryption. You should enable encryption if you are using a public network or if you are performing connections over the Internet (to stop others from being able to intercept your data).

You can add options to the command line to specify the resolution and also the color depth of the display. The higher the resolution and color depth (can be adjusted to use 8 to 32 bits per pixel to provide low or high color detail), the more data has to be transferred through the network link. If you find the refresh rate a little slow, try reducing these numbers as follows:

vncserver :1 –geometry 1280x780 –depth 24

To allow the VNC server to start automatically when you switch on, you can add the vncserver command to .bash_profile (this is executed each time the Raspberry Pi starts).

Use the nano editor as follows (the -c option allows the line numbers to be displayed):

sudo nano -c ~/.bash_profile

Add the following line to the end of the file:

vncserver :1

The next time you power up, you should be able to remotely connect using VNC from another computer.

If you are running the latest version of Raspbian, SSH and X11 Forwarding will be enabled by default (otherwise, double-check the settings explained in the How it works… section).

Linux and OS X have built-in support for X11 Forwarding; but if you are using Windows, you will need to install and run the X Windows server on your computer.

Download and run xming from the Xming site (http://sourceforge.net/projects/xming/).

Install xming, following the installation steps, including the installation of PuTTY if you don't have it already. You can also download PuTTY separately from http://www.putty.org/.

Next, we need to ensure the SSH program we use has X11 enabled when we connect.

For Windows, we shall use PuTTY to connect to the Raspberry Pi.

In the PuTTY Configuration dialog box, navigate to Connection | SSH | X11 and tick in the checkbox for X11 Forwarding. If you leave the X display location option blank, it will assume the default Server 0:0 as follows (you can confirm the server number by moving your mouse over the Xming icon in the system tray when it is running):

Enabling X11 Forwarding within the PuTTY configuration

Enter the IP address of the Raspberry Pi in the Session settings (you may also find that you can use the Raspberry Pi's hostname here instead; the default hostname is raspberrypi).

Save the setting using a suitable name, RaspberryPi, and click on Open to connect to your Raspberry Pi.

You are likely to see a warning message pop up stating you haven't connected to the computer before (this allows you to check you have everything right before continuing).

Opening an SSH connection to the Raspberry Pi using PuTTY

For OS X or Linux, click on Terminal to open a connection to the Raspberry Pi.

To connect with the default pi username, with an IP address of 192.168.1.69, use the following command; the -X option enables X11 Forwarding:

ssh -X pi@192.168.1.69

All being well, you should be greeted with a prompt for your password (remember the default value for the pi user is raspberry).

Ensure that you have Xming running, bystarting the Xming program from your computer's Start menu. Then, in the terminal window, type a program that normally runs within the Raspberry Pi desktop, such as leafpad or scratch. Wait a little while and the program should appear on your computer's desktop (if you get an error, you have probably forgotten to start Xming, so run it and try again).

X Windows and X11 is what provides the method by which the Raspberry Pi (and many other Linux-based computers) can display and control graphical Windows as part of a desktop.

For X11 Forwarding to work over a network connection, we need both SSH and X11 Forwarding enabled on the Raspberry Pi. Perform the following steps:

SSH and X 11 Forwarding is a convenient way to control the Raspberry Pi remotely; we will explore some additional tips on how to use it effectively in the following sections.

leafpad &

_tkinter.TclError: couldn't connect to display "localhost:10.0"

sudo cp ~/.Xauthority ~root/

Ensure that you have the Raspberry Pi powered and running with a working connection to the Internet.

You will also need another computer on the same local network to test the new share.

First, we need to install samba, a software that handles folder sharing in a format that is compatible with Windows sharing methods.

Ensure that you use update as follows to obtain the latest list of available packages:

sudo apt-get update
sudo apt-get install samba

The install will require around 20 MB of space and take a few minutes.

Once the install has completed, we can make a copy of the configuration file as follows to allow us to restore to defaults if needed:

sudo cp /etc/samba/smb.conf /etc/samba/smb.conf.backup
sudo nano /etc/samba/smb.conf

Scroll down and find the section named Authentication; change the # security = user line to security = user.

As described in the file, this setting ensures that you have to enter your username and password for the Raspberry Pi in order to access the files (this is important for shared networks).

Find the section called Share Definitions and [homes], and change the read only = yes line to the read only = no line.

This will allow us to view and also write files to the shared home folder. Once done, save and exit by pressing Ctrl + X, Y, and Enter.

Now, we can add pi (the default user) to use samba as follows:

sudo pdbedit -a -u pi

Now, enter a password (you can use the same password as your login or select a different one, but avoid using the default Raspberry password, which would be very easy for someone to guess). Restart samba to use the new configuration file as follows:

sudo /etc/init.d/samba restart
[ ok ] Stopping Samba daemons: nmbd smbd.
[ ok ] Starting Samba daemons: nmbd smbd.

In order to test, you will need to know either the Raspberry Pi's hostname (the default hostname is raspberrypi) or its IP address. You can find both of these with the following command:

hostname

For the IP address, add -I as follows:

hostname –I

On another computer on the network, enter the \\raspberrypi\pi address in the explorer path.

Depending on your network, the computer should locate the Raspberry Pi on the network and prompt for a username and password. If it can't find the share using the hostname, you can use the IP address directly, where 192.168.1.69 should be changed to match the IP address, \\192.168.1.69\pi.

You will need to be connected to the Internet in order to update your system. It is always advisable to make a backup of your image first (and at a minimum, take a copy of your important files).

You can check your current version of firmware with the uname -a command as follows:

Linux raspberrypi 3.1.9+ #168 PREEMPT Sat Jul 14 18:56:31 BST 2012 armv6l GNU/Linux

The GPU firmware can be checked using the /opt/vc/bin/vcgencmd version command as follows:

   Jul 14 2012 13:14:40
Copyright (c) 2012 Broadcom
version 325444 (release)

This is important if you are using an older version of firmware (pre-November 2012) on a newer board since the Model B board was only 254 MB RAM. Upgrading allows the firmware to make use of the extra memory if available.

The free -h command will detail the RAM available to the main processor (the total RAM is split between the GPU and ARM cores) and will give the following output:

             total       used       free     shared    buffers     cached
Mem:          183M       125M        58M         0B       9.1M        96M
-/+ buffers/cache:        19M       164M
Swap:          99M         0B        99M

You can then recheck the preceding output following a reboot to confirm if they have been updated (although they may have already been the latest).

Before running any upgrades or installing any packages, it is worth ensuring you have the latest list of packages in the repository. The update command gets the latest list of available software and versions:

sudo apt-get update

If you just want to obtain an upgrade of your current packages, upgrade will bring them all up to date:

sudo apt-get upgrade

To ensure that you are running the latest release of Raspbian, you can run dist-upgrade (be warned; this can take an hour or so, depending on the amount that needs to be upgraded). This will perform all the updates that upgrade will perform but will also remove redundant packages and clean up:

sudo apt-get dist-upgrade

Both methods will upgrade the software, including the firmware used at boot and startup (bootcode.bin and start.elf).