Noble Origins

The Raspberry Pi was designed to be a platform to explore topics in computer science. The designers saw the need to provide inexpensive, accessible computers that could be programmed to interact with hardware such as servo motors, display devices, and sensors. They also wanted to break the mold of having to spend hundreds of dollars on a personal computer and thus make computers available to a much wider audience.

The designers observed a decline in the experience of students entering computer science curriculums. Instead of having some experience in programming or hardware, students are entering their academic years having little or no experience with working with computer systems, hardware, or programming. Rather, students are well versed in Internet technologies and applications. One of the contributing factors cited is the higher cost and greater sophistication of the personal computer, which means parents are reluctant to let their children experiment on the family PC.

This poses a challenge to academic institutions, which have to adjust their curriculums to make computer science palatable to students. They have had to abandon lower-level hardware and software topics due to students’ lack of interest or ability. Students no longer wish to study the fundamentals of computer science such as assembly language, operating systems, theory of computation, and concurrent programming. Rather, they want to learn higher-level languages to develop applications and web services. Thus, some academic institutions are no longer offering courses in fundamental computer science.⁴ This could lead to a loss of knowledge and skill sets in future generations of computer professionals.

To combat this trend, the designers of the Raspberry Pi felt that, equipped with the right platform, youth could return to experimenting with personal computers as in the days when PCs required a much greater commitment to learning the system and programming it in order to meet your needs. For example, the venerable Commodore 64, Amiga, and early Apple and IBM PC computers had very limited software offerings. Having owned a number of these machines, I was exposed to the wonder and discovery of programming at an early age.⁵

The Raspberry Pi is an attempt to provide an inexpensive platform that encourages experimentation. The following sections explore more about the Raspberry Pi, including the models available, required accessories, and where to buy the boards.

Models

There are currently two model classifications of Raspberry Pi boards: Model A and Model B. The early Model A boards were the first mass-produced boards with 256MB of RAM, one USB port, and no Ethernet port. This was followed closely by the first Model B board, which had 512MB of RAM, two USB ports, and an Ethernet port. Figure 5-1 shows the version 3 variant of the Model A board designated as Raspberry Pi 3A+.

Figure 5-2 shows the version 3 Model B board designated as Raspberry Pi 3B+. Notice the board is a bit larger and has more connections.

Figure 5-3 shows the latest Model B board designated as the Raspberry Pi 4B. The figure depicts some of the improvements from the 3B+ model including more RAM, USB-C power, two HDMI ports, and USB 3 support. Plus, it is the fastest Raspberry Pi computer to date!

You can often find the Raspberry Pi 3A+ at online retailers and auction sites for a bit less than the Raspberry Pi 3B+ board. The newest Raspberry Pi 4B are still in high demand so you may pay more for those boards but shop around to find retailers that offer the board at suggested retail prices of $35 (1GB), $45 (2GB), $55 (4GB), or $91 (8GB). If you plan to use the Raspberry Pi for experimentation and do not need the extra memory to run memory-intensive applications, you can use the Raspberry Pi 3A+.

A Tour of the Board

Not much larger than a deck of playing cards, the Raspberry Pi board contains a number of ports for connecting devices. This section presents a tour of the board. If you want to follow along with your board, hold it with the Raspberry Pi logo faceup. I will work around the board clockwise. Figure 5-4 depicts a drawing of the board with all the major connectors labeled.

In the center of the near side, you see an HDMI connector. To the left of the HDMI connector is the micro-USB power connector and to the right is the camera connector and audio connector. The power connector is known to be a bit fragile on some boards, so take care plugging and unplugging it. Be sure to avoid putting extra strain on this cable while using your Raspberry Pi.

On the left side of the board, we see the location of the WiFi chip. On the underside of the board is where the microSD card connector is located. Interestingly, most cases are not designed to protect the microSD card. When installed, the microSD card protrudes a few centimeters out of the board.

On the far side of the board is the general-purpose input/output (GPIO) header (a double row of 20 pins), which can be used to attach to sensors and other devices. You will work with this connector later in this chapter.

On the right side of the board are four USB connectors and the Ethernet connector. An external powered USB hub connected to the USB ports on the Raspberry Pi can power some boards, but it is recommended that you use a dedicated power supply connected to the micro-USB connector.

Take a moment to examine the top and bottom faces of the board. As you can see, components are mounted on both sides. This is a departure from most boards that have components on only one side. The primary reason the Raspberry Pi has components on both sides is that it uses multiple layers for trace runs. This permits the board to be much smaller and enables the use of both surfaces for mounting its components. This is probably the most compelling reason to consider using a case—to protect the components on the bottom of the board and thus avoid shorts and board failure.

Required Accessories

The Raspberry Pi is sold as a bare system board with no case, power supply, or peripherals. Depending on how you plan to use the Raspberry Pi, you need a few commonly available accessories. If you have been accumulating spares like me, a quick rummage through your stores may locate most of what you need.

If you want to use the Raspberry Pi in console mode (no graphical user interface), you need a USB power supply (USB-C for the Raspberry Pi 4B), a keyboard, and an HDMI cable and monitor. The power supply should have a minimal rating of 2500mA or greater for the Raspberry Pi 3B, 3B+ boards, and 3000mA USB-C (15 Watt) or greater for the Raspberry Pi 4B. If you want to use the Raspberry Pi with a graphical user interface, you also need a mouse.

If you have to purchase these items, stick to the commonly available brands and models without extra features. For example, avoid the latest multifunction keyboard and mouse. Chances are they require drivers that are not available for the various operating system choices for the Raspberry Pi.

You also must have a microSD card. I recommend a 16GB or higher version. Recall that the microSD is the only onboard storage medium available. You will need to put the operating system on the card, and any files you create will be stored on the card.

If you want to use sound in your applications, you also need a set of powered speakers that accept a standard 3.5mm audio jack. Finally, if you want to connect your Raspberry Pi to the Internet, you need access to a WiFi access port or an Ethernet hub.

Recommended Accessories

I highly recommend at least adding small rubber or silicone self-adhesive bumpers to keep the board off your desk. On the bottom of the board are many sharp prongs that can come into contact with conductive materials, which can lead to shorts or, worse, a blown Raspberry Pi. These bumpers are available at most home-improvement and hardware stores.

If you plan to move the board from room to room or you want to ensure that your Raspberry Pi is well protected against accidental damage, you should consider purchasing a case to house the board. Many cases are available, ranging from simple snap-together models to models made from laser-cut acrylic or even milled aluminum. The following list includes several excellent choices, complete with vendor links.

Pi Tin

The Pi Tin from SparkFun is a basic, clear, two-piece case that snaps together. It uses light pipes to make reading the status LEDs easier and has cutouts for the GPIO header. It is inexpensive and an excellent choice for the budget minded. It is made for the Raspberry Pi 3B+. Figure 5-5 shows the Pi Tin from SparkFun (www.sparkfun.com/products/13103).

Aluminum Heatsink Case for Raspberry Pi 4B

The Aluminum Heatsink Case for Raspberry Pi 4B from SparkFun is an example of a good metal case with heat sink made for the Raspberry Pi 4B. It is made with two pieces of metal that have built-in heat sink pads that bolt together. It is a minimalist design that doesn’t make the board much larger (but is heavier). It is a bit more expensive than the basic plastic cases and provides better cooling and protection, and, to me, it also looks better than others. Figure 5-6 shows the Aluminum Heatsink Case from SparkFun (www.sparkfun.com/products/15773). I have also seen versions of this design that have one or two fans on top if you need extra cooling.

Pibow Coupé

The Pibow Coupé (www.adafruit.com/products/2083) is available from Adafruit and other vendors and comes in various colors for both the Raspberry Pi 3B+ and 4B (there are also available for other Raspberry Pi boards). It is made from pieces of acrylic, but they’re arranged in a novel slice pattern. To assemble the Pibow, you place the Raspberry Pi on the bottom plate and stack the layers, finishing with the top plate. Key layers provide cutouts for all ports including the GPIO header. Four nylon fasteners secure the case as a unit. Once assembled, the case looks great and is very solid. Figure 5-7 shows the Pibow Coupé for Raspberry Pi 3B+ from Adafruit.

Tip

If none of these cases meet your needs or aesthetic choices, you can find a host of options from Adafruit at www.adafruit.com/category/395. You’re sure to find what you want there!

Aside from a case, you should also consider purchasing (or pulling from your spares) a powered USB hub. The USB hub power module should be 2500mA or more (some suggest you need only a 1500mA, but more is better especially if you want to connect USB devices to your board). A powered hub is required if you plan to use USB devices that draw a lot of power, such as a USB hard drive or a USB soft missile launcher.

Getting Started

As mentioned in the “Required Accessories” section, you need a microSD card (16GB is recommended), a USB power supply rated at 2500mA or better with a male micro-USB connector (or USB-C for Raspberry Pi 4B), a keyboard, a mouse (optional), and an HDMI cable and monitor or a DVI monitor with an HDMI adapter. However, before you can plug these things in to your Raspberry Pi and bask in its brilliance, you need to create a boot image for your microSD card.

Installing a Boot Image

The process of installing a boot image involves choosing an image, downloading it, and then copying it to your microSD (hence simply SD) card. The following sections detail the steps involved.

Booting Up

To boot your Raspberry Pi, insert the SD card with the new image and plug in your peripherals. Wait to plug in the USB power last. Because the Raspberry Pi has no On/Off switch, it will start as soon as power is supplied. The following describes the process you will see and follow to boot Raspbian for the first time. The setup steps are executed only once (but you can change the settings later if you want).

When you power on the Raspberry Pi, the system bootstraps and then starts loading the OS. You see a long list of statements that communicate the status of each subsystem as it is loaded, followed by a welcome banner. You don’t have to try to read or even understand all the rows presented,⁷ but you should pay attention to any errors or warnings.

You may also see a message about resizing the boot device and your Raspberry Pi may reboot. This is automatic and nothing to be concerned about. In fact, it is ensuring the boot volume is expanded to the maximum size your microSD supports. When the boot sequence is complete, you will see the Raspbian desktop as shown in Figure 5-8.

Figure 5-9 shows each step starting from the upper left working left to right.

When the system next boots, you will see the Raspbian desktop with your settings configured. If you set up a WiFi connection, it will automatically reconnect. Nice.

GPIO Pin Mapping

The Raspberry Pi has a special hardware feature called the general-purpose I/O (GPIO) header. It is located in the upper-left portion of the board and resembles a floppy drive header.⁸ The header consists of two rows of 20 male pins.

All GPIO pins can be configured as either input (reading) or output (writing). The voltage read can be used for digital I/O. Specifically, when the voltage is less than 1.7V, the value is 0; greater than 1.7V is a value of 1. For output pins, you can set the voltage from 0 to 3.3V.

Figure 5-10 shows the layout of the GPIO header of the Raspberry Pi 3B+ (and 4B).

Notice that the pins are not named in order. For example, there are GPIO 1 and GPIO 2, but they aren’t next to each other on the header (GPIO 1 is on the right at position or pin 28 and GPIO 2 is on the left at header position or pin 3). This naming may be a source of confusion because it doesn’t follow what you would expect, nor does it mirror the neat layout of microcontrollers like the Arduino. Thus, when working with the GPIO header, you should check your pin choices carefully.

Also notice that some pins have two names. For example, GPIO 14 and GPIO 15 are also named TXD (transmit) and RXD (receive), respectively. These pins can be used for serial communication. GPIO 18 and GPIO 21 are labeled PWM (pulse wave modulation), which is used for powering LEDs, motors, and similar devices. GPIO 0 and GPIO 1 are also named SDA and SCL, respectively, and are used for I2C communication. I2C is a fast digital protocol that uses two wires (plus power and ground) to read data from circuits (or devices). Finally, GPIO 9, GPIO 10, and GPIO 11 are also named MISO, MOSI, and SCKL, respectively, and are used for SPI communication.

Adafruit has a nifty accessory that makes working with the GPIO a lot easier. It is a small PCB with the layout of the GPIO imprinted on it. It’s called the GPIO reference card and can be found at https://www.adafruit.com/product/2263. Figure 5-11 shows what the card looks like (rotated for brevity and enlarged for detail). I recommend buying one the next time you order from Adafruit.

If you want to ensure that you are protecting your Raspberry Pi from higher voltage and current, most expansion boards have additional circuitry for power protection. A number of expansion boards are available, including the Gertboard (www.element14.com/community/docs/DOC-51726?ICID=raspberrypi-gert-banner). This book does not cover the use of expansion boards, but you may want to consider using expansion boards if your sensors involve complex circuitry that requires more ports or additional features like motor controllers or relays.

Rather than expansion boards, here you use a simple prototyping board instead. The one I’ve chosen is called the Pi T-Cobbler Plus breakout board and is available from Adafruit (www.adafruit.com/products/2028). It features a ribbon cable and a breadboard-compatible connector with the pins arranged in the same order as those on the Raspberry Pi. Figure 5-12 shows the Pi T-Cobbler Plus. The board does not provide any additional functionality other than making it easier to work with GPIO by connecting the Raspberry Pi to a breadboard.

I’ve found it best to make the connections with the Raspberry Pi powered off and to take a couple of passes verifying the connections are connected to the right pins. It is very easy to connect to the wrong pin—there are so many, and they are in close proximity. The odd arrangement of the pin numbers doesn’t help either. Properly admonished, let’s jump into working with your Raspberry Pi GPIO and hook up some sensors!

A smaller alternative of the Pi T-Cobbler places the ribbon connector in the center and takes up less room on a breadboard. This version is called the Pi Cobbler Plus and is available at www.adafruit.com/products/2029. Figure 5-13 shows the Pi Cobbler Plus.

You can also find several variants on the Pi T-Cobbler Plus and Cobbler Plus on popular online auction and electronics discount sites. One fine example is the SparkFun Pi Wedge from SparkFun (www.sparkfun.com/products/13717). This board has a similar layout to the Pi T-Cobbler Plus but arranges the GPIO pins in a slightly different order (but is printed on the PCB for easy reference).

Whichever breakout board you choose, it will permit you to connect your Raspberry Pi to a breadboard, making experimentation with electronics (and sensors) much easier. It won’t protect you against accidental power overload, so be mindful of that. The following projects use a breadboard; so, if you have a Pi Cobbler, connect your Raspberry Pi to your breadboard.

Now that you know how to connect hardware to the GPIO pins, you need to know what software is required to allow you to write programs to read from and write to those pins.

Required Software

You need to install a number of software packages to work with the GPIO header. This section examines the required software for using the Python programming language. You can use C and Scratch language extensions, but Python is the best to learn because it is syntactically easy to read and easy to master. Also, the designers of the Raspberry Pi chose Python initially as its only language, so you are likely to find more examples on the Internet to which to refer for ideas and help. We have already seen a tutorial on MicroPython, and the Python we will be using on the Raspberry Pi is nearly identical at least in terms of how we write the code.

By default, the Raspbian includes Python and a host of supporting libraries. But it does not include everything you need. To fully access all the GPIO features, you also need the Raspberry Pi Python GPIO module (RPi.GPIO) for communicating with the GPIO pins, pySerial for connecting to serial devices, and python-smbus for accessing the I2C bus. If you use an expansion board, the manufacturer may also have special modules you need to install. No special modules are needed for the Pi T-Cobbler breakout board. If you are interested in writing games, you may also want to install the python-game package.

Now that you have the software loaded, it’s time to experiment! If you haven’t plugged in your breakout board, shut down your Raspberry Pi (using sudo shutdown –h now from a terminal or the shutdown from the Raspbian menu) and connect the breakout board, and then restart your Raspberry Pi.

Project: Hardware “Hello, World!”

In this project, you will build a “Hello, World!” project for the Raspberry Pi. This project uses an LED that the Raspberry Pi turns on and off through calls to a Python library function. That’s a fine project for getting started, but it does not relate to how sensors could be used.

Thus, in this section, you will use a modified LED project where we simply trigger an LED by adding a sensor. In this case, you still keep things simple by using what is arguably the most basic of sensors: a pushbutton. The goal is to illuminate the LED whenever the button is pushed.

Hardware Connections

Let’s begin by assembling a Raspberry Pi, Pi T-Cobbler from Adafruit (optional), breadboard, one LED, and one pushbutton. You start with the Raspberry Pi powered down.

Plug the breakout board into the breadboard. Wire the 3.3V pin, not the 5V pin, to the breadboard power rail, the ground pin to the ground rail, and a loop around to the other side of the board. This connection provides power to the breakout board. Thus, you do not need a breadboard power supply.

Place the LED and pushbutton to one side of the breadboard, as shown in Figure 5-14. Remember, the longest leg on the LED is the positive side. Notice that I show the Raspberry Pi and the Pi Cobbler breakout board but not the cable to the Raspberry Pi, for brevity. The Raspberry Pi is connected via a ribbon cable to the Pi Cobbler Plus (you can use the T-Cobbler Plus in the same manner). Be sure to align the cable so the colored stripe (indicating pin 1) is aligned with pin 1 on the connector. Do this for both the Raspberry Pi and the breakout board.

Caution

Connecting the 5V pin to any other pin on the GPIO header can damage your Raspberry Pi. If you use a sensor that requires 5V input, be sure to double-check that its maximum output is 3.3V or less.

You’re almost there. Now wire a jumper from the power rail to one side of the pushbutton, and wire the other side of the pushbutton to pin GPIO 17 on the breakout board (pin 6 on the left side). Wire the LED to ground on the breadboard and a 150 Ohm resistor (colors: brown, green, brown, gold). The other side of the LED should be wired to pin GPIO 7 on the breakout board (see Figure 5-13).

You also need a resistor to pull the button low when the button is not pressed. Place a 10K Ohm resistor (colors: brown, black, orange, gold) on the side of the button with the wire to pin GPIO 17 and ground. The shortest side of the LED is the ground side. This side should be the one connected to the resistor. It does not matter which direction you connect the resistor. It is used to limit the current to the LED. Check the drawing again to ensure that you have a similar setup.

A Cool Gadget

One of the coolest gadgets for working with the Raspberry Pi is the Raspberry Pi Dish mounting plate from Adafruit (www.adafruit.com/products/942). This small acrylic plate has space for a full-sized breadboard and a Raspberry Pi. It even has mounting holes for bolting the Raspberry Pi to the plate and small rubber feet to keep the plate off the work surface. The following figure shows the mounting plate in action. Note that this image shows an older Raspberry Pi board, but all of the latest Raspberry Pi boards fit.

Although you can make your own Raspberry Pi mounting plate from Lexan or Plexiglas, the Adafruit product is a notch better than what you can make yourself. For about $23.00, you can keep your Raspberry Pi and breadboard together and avoid scratches to your table and shorts caused by components on the bottom of the Raspberry Pi coming into contact with conductive material.

Hardware Setup

The hardware needed for this project is a breadboard, a breakout board for the Raspberry Pi (such as Pi Cobbler+), a DS18B20 digital temperature sensor, a 0.10mF capacitor, and some jumper wires. Insert your breakout board into the breadboard, aligning pin 1 (3.3V) to position 1 on the breadboard. This will help you orient the pins more easily by using the numbers on the breadboard to quickly find the pins without counting (and miscounting) them. Figure 5-15 shows the correct orientation of the breakout board. I omit the ribbon cable for brevity.

Next, install the temperature sensor to the right of the breakout board with pin 1 to the left. If you hold the sensor such that the flat side is facing you, pin 1 is on the left of the flat side of the sensor. Connect the 0.10mF capacitor between pin 3 (right) and pin 2 (center) or use jumpers as shown in Figure 5-15.

Connect power from the breakout board to the power rail of the breadboard and ground from the breakout board to the ground rail of the breadboard, as shown in Figure 5-14. Next, connect power to pin 3 of the sensor and ground to pin 1. Finally, connect pin 2 of the sensor to GPIO 4. Why GPIO 4? Because the sensor is a digital sensor, and you can use the one-wire facility (because it uses only a single data wire) to read the data. Cool, eh?

Testing the Hardware

Once you have double-checked your connections, go ahead and boot up your Raspberry Pi. Because the sensor uses the one-wire protocol to read data, you can use features built into the Raspberry Pi to read data from the sensor. This isn’t nearly as elegant as writing a Python script, but it will permit you to see that all is working correctly before you start programming.

You will use a special utility called modprobe . This utility loads (or unloads) modules into the Linux kernel. In the vernacular of other operating systems, it loads device drivers. The modprobe utility can do far more than just load modules (drivers); to learn more about it, see http://linux.die.net/man/8/modprobe.

The modules you want to load are named w1-gpio and w1-therm. The w1-gpio module registers and loads the new sensor connected to pin GPIO 4. The w1-therm module registers and loads a module that has support for temperature sensors.

When you use modprobe to load each of these modules (w1-gpio first), the Raspberry Pi enables data collection on pin GPIO 4 and reads data from the sensor and stores it in a file. The file is named starting with 28 and followed by a unique file name. If you had other sensors, there would be a file for each one.

Notice that in the example I ran the cat⁹ (concatenate and print) utility to print out the data in the file several times. I placed my hand over the sensor while running the utility in order to simulate an increase in temperature. Can you see how the values changed?

Software Setup

Notice that you know the parent directory and the starting portion of the directory. The glob module does all the work for you. If there were multiple directories matching the wildcard, the call would return a list. In this case, you have only one sensor, so you can expect only one directory.

As you can see, it is very straightforward and reads like the steps you would imagine. Specifically, you open the file, read all the lines in the file, close the file, and return what you read.

This method has two parts. The first part reads the data from the file using the previous method and checks the first line (arrays and lists start with index 0 in Python) to see if the status is YES . If it isn’t, you read the line from the file again and repeat until you find a file that has the correct, valid status.

The next part looks in the file for the data read. In this case, you look for a substring that starts with t= and then read the data after that and convert it to Celsius and Fahrenheit. You return those values for use in printing the data.

Let’s put it all together. Listing 5-3 shows the completed script, including documentation. Open an editor, create a file named pi_temp.py, and enter the source code shown. Feel free to modify it to suit your mood or particular brand of humor.

Take a few minutes to double-check your file to make sure you have typed all the statements correctly. If you have an editor on your desktop or laptop, you might want to use it to create and edit the file using the syntax-checking feature to catch any errors. The script won’t run correctly on your desktop or laptop, but checking the syntax can be a big help.

Now that the software is written, let’s see what it does.

Testing the Sensor

If you get syntax errors, go back and check that you have entered every line exactly as shown in Listing 5-3. Python is really good at providing enough information to fix most syntax errors. If you encounter any, you see not only what the error is but also the line number of the file where the error occurs. Once you have fixed the error, try the script again until you see the correct output.

The next section explores a more complex project in which the Raspberry Pi communicates with a digital sensor that uses the I2C protocol.

For More Fun

To make this project a bit more fun, try connecting a second sensor (of the same type), and print out the data including the sensor from which the data was read. Hints: You can use the serial number embedded in the file to identify the sensor, and you should connect them in parallel. That is, each sensor connects to the same ground (pin 1) and power connections (pin 3). The data output (pin 2) of each sensor is wired to the same GPIO pin.

For extra-special fun, modify the code to detect when the sensor read has failed and print an appropriate error message. Can you spot where this is possible?¹¹ I’ll give you a hint: what happens in the get_temp() method if t= is not found?

Hardware Setup

The hardware needed for this project is a breadboard, a breakout board for the Raspberry Pi (such as Pi Cobbler+), a BMP280 sensor module, and some jumper wires. Insert your breakout board into the breadboard, aligning pin 1 (3.3V) to position 1 on the breadboard.

Connect the 5V pin on the Raspberry Pi Cobbler+ board to power on the sensor module. Connect the ground wire to the ground wire on the sensor. The I2C pins on the Raspberry Pi are pins GPIO 0 (SDA) and GPIO 1 (SCL). Connect wires from these pins to corresponding pins on the sensor module (SDA goes to SCK on the BMP280, SCL goes to SDI on the BMP280). Figure 5-18 shows the physical connections.

Testing the Hardware

Notice in the example that the graph shows data in column 7 for row 70 and a value of 77. This means the sensor is at address 0x77 (in hexadecimal). If other sensors were installed, they would appear in the graph as well. Remember this address, because you need it for the code.

Software Setup

The software required for this project requires the Python libraries you installed earlier as well as a special library designed to communicate with the BMP280. You need a special module because the I2C protocol is bidirectional, and most I2C components are designed to respond to one or more commands to evoke data generation. In this case, you need a Python module that supports the BMP280 sensor module.

The library has been created by the nice people at Adafruit and is available for download from the Python package repository (PyPi¹²). You can find comprehensive documentation for the library at https://readthedocs.org/projects/adafruit-circuitpython-bmp280/downloads/pdf/latest/.

Now let’s put it all together. Listing 5-4 shows the complete listing of the script. Open an editor, create a file named pi_bmp280.py, and enter the source code shown.

Now that the software is written, let’s see what it does.

Testing the Sensor

The next section explores a more complex project in which the Raspberry Pi is a data collector (an aggregate node) hosting sensor data via an XBee wireless connection to a sensor node. You will reuse the sensor node created in Chapter 4. If you have not read through and succeeded in building the projects in Chapter 4, you may want to go back and complete the last project before proceeding.

For More Fun

The BMP280 sensor reads the barometric pressure, as you have seen, but it also reads temperature. Change the previous code to read the temperature data as well as the barometric pressure.

XBee Sensor Node

Follow the text from Chapter 4 to create the XBee sensor node. As a reminder, this node is constructed as shown in Figure 5-19.

Hardware

The hardware setup for this project is very easy. All you need to do is use the serial interface that is part of the GPIO header to connect to the XBee’s serial interface. It’s that easy! Do not power on your Raspberry Pi or sensor node until after all hardware connections are complete and verified correct. I will tell you when to power up later in this section.

You need a breadboard and an XBee breadboard adapter like the one you used in Chapter 4; plug it into the breadboard. Then plug in your Raspberry Pi breadboard adapter. Now wire the 3.3V and ground to the pins on your XBee adapter. If you are using the XBee Explorer Regulated from SparkFun (www.sparkfun.com/products/11373), you can connect to the 5V power because the XBee Explorer can regulate the power (hence the name). The SparkFun board as shown has the serial interface pins arranged in a header on one side of the board. It also has onboard voltage regulation to protect the XBee in the event you accidentally connect the 5V pin instead of the 3.3V pin to the explorer.

Next, wire the TXD (output) pin GPIO 14 on the Raspberry Pi Cobber+ to the DIN pin on the XBee Explorer. Then wire the RXD (input) pin GPIO 15 on the Raspberry Pi Cobble+ to the DOUT pin on the XBee Explorer. Figure 5-20 shows the completed connections.

If you are not using the SparkFun adapter , be sure to check the documentation on your adapter to make sure you are connecting the right pins. Take your coordinator XBee module and insert it into the XBee.

There is one more thing you need to do. The designers of the Raspberry Pi included the facility to connect a serial terminal to the Raspberry Pi at boot time. There is a setting in the preferences that allows you to enable this interface. It is disabled by default.

To turn on the serial interface, open a terminal and enter the command sudo raspi-config . This opens the Raspberry Pi configuration tool. To enable the serial interface, select the Interfacing Options in raspi-config. The easiest way is to use the arrow keys and highlight the selection and press ENTER.

On the next screen, choose the Serial option, then follow the next three screens to disable login shell over serial (choose No), enable the hardware serial port (choose Yes), and then press ENTER on the confirmation page.

When control returns to the main screen, use the Tab key to select Finish and then Yes to allow the Raspberry Pi to reboot. Figure 5-21 shows the sequence of screens and the options you should choose.

After your machine reboots, we can install the software we need for the project.

Software

This library has a host of classes used to work with XBee modules and has numerous examples you can use for your own projects. We are going to see just one of the ways you can use the library. For more details about other features in the library, you can download the Digi-Python Programmers Guide using the following URL: https://xbplib.readthedocs.io/en/latest/getting_started_with_xbee_python_library.html

If you want to see the code for the library itself, you can see it on GitHub at https://github.com/digidotcom/xbee-python.

Now we’re ready to get to the core of the program. We will use two techniques that you may not have seen before using methods. First, we will create a method to connect to the ZigBee network and retrieve an instance of the remote XBee module class that we can use to read data. Second, we will create a second method to be used to read data at the sampling rate. This is called a callback method since it is used by the libraries to “call back” to your program whenever the sampling rate dictates reading data.

Notice we also placed the code to decipher the data in this method. Specifically, we calculate the temperature in Celsius, convert it to Fahrenheit, and calculate the voltage at the node. I leave the details of the code as an exercise, but we’ve used the formulas in previous examples.

Testing the Final Project

Did you see something similar? If so, you’re doing great work and now have the knowledge needed to build sensor nodes and Raspberry Pi–based sensor data aggregators.

If you do not see any data at all, go back to Chapter 4 and follow the troubleshooting tips from the last project in the chapter. You can always plug the coordinator module into a USB explorer and use a terminal program on your personal computer to see if data is being received from the XBee sensor node.

For More Fun

If you would like to expand the project, you can add a second XBee sensor node and modify the code to specify which node the data came from. For example, the script should record (write to standard output) the source of the data along with the sensor data from the XBee.