Raspberry Pi Workshop Workbook

Introduction

Hi, I’m Marcus Schappi and welcome to the Raspberry Pi Workshop book.
The Raspberry Pi is a tiny power computer created by the Raspberry Pi Foundation to teach electronics and programming. Despite it’s small size, the Raspberry Pi is infact quite a versalite little computer that can be put to use in many projects.

In this workbook we’ll explore how the Raspberry Pi works and build some simple experiments and projects that you can replicate at home or in the classroom. By the time you’ve finished with this book you’ll have a better knowledge of the Raspberry Pi and do-it-yourself computing as a whole.

What you need to know before reading this book

This workshop is designed for computing and software enthusiasts. If you’ve purchased from Little Bird Electronics, chances are you’re almost certainly the right fit!

You don’t need to know how to program or electronics, but a cursory knowledge will help!

Getting Up and Running

A quick tour of the Raspberry Pi

Getting our Raspberry Pi onto the network

Command Line Cheat Sheet

Directories

$ pwd
Display path of current working directory

$ cd <directory>
Change directory to <directory>

$ cd ..
Navigate to parent directory

$ ls ..
List directory contents

$ ls -la
List detailed directory contents, including hidden files

$ mkdir <directory>
Create a new directory named <directory>

Files

$ rm <file>
Delete <file>

$ rm -r <directory>
Delete <directory>

$ rm -f <file>
Force-delete <file> (add -r to force-delete a directory)

$ mv <file-old> <file-new>
Rename <file-old> to <file-new>

$ mv <file> <directory>
Move <file> to <directory> (possibly overwriting an existing file)

$ cp <file> <directory>
Copy <file> to <directory> (possibly overwriting an existing file)

$ cp -r <directory1> <directory2>
Copy <directory1gt; and its contents to <directory2gt; (possibly overwriting files in an existing directory)

$ touch <file>
Update file access & modification time (and create <file> if it doesn’t exist)

Output

$ cat <file>
Output the contents of <file>

$ less <file>
Output the contents of <file> using the less command (which supports pagination etc.)

$ head <file>
Output the first 10 lines of <file>

$ <cmd> > <file>
Direct the output of <cmd> into <file>

$ <cmd> >> <file>
Append the output of <cmd> into <file>

$ <cmd1> | <cmd2>
Direct the output of <cmd1> to <cmd2>

$ clear
Clear the command line window

Permissions

$ chmod +x <file>
Make executable

$ chmod -R 600 <directory>
Change permissions of <directory> (and it’s contents to 600)

$ chown <user>:<group> <file>
Change ownership of <file> to <user> and <group> (add -R to include a directory’s contents)

Search

$ find <dir> -name "<file>"
Find all files named <file> inside <dir> (use wildcards [*] to search for parts of filenames, e.g. “file.*”)

$ grep "<text>" <file>
Output all occurrences of <text> inside <file> (add -i for case-insensitivity)

$ grep -rl "<text>" <dir>
Search for all files containing <text> inside <dir>

Network

$ ifconfig
Print out the network interface parameters

$ ping <host>
Ping <host> and display status

$ whois <domain>
Output whois information for <domain>

$ curl -O <url/to/file>
Download <file> (via HTTP[S] or FTP) using curl

$ wget <url/to/file>
Download <file> (via HTTP[S]) using wget

$ ssh <username>@<host>
Establish an SSH connection to <host> with user <username>

$ scp <file> <user>@<host>:/remote/path
Copy <file> to a remote <host>

Processes

$ ps ax
Output currently running processes

$ top
Display live information about currently running processes

$ kill <pid>
Quit process with ID <pid>

$ pkill <name>
Quit process with <name>

Sound

$ aplay <file>
Play sound file <file>

$ amixer sset 'PCM' 80%
Set the volume to 80%

$ amixer cset numid=3 0
Set the sound output to Automatic

$ amixer cset numid=3 1
Set the sound output to analogue (headphone jack)

$ amixer cset numid=3 2
Set the sound output to HDMI

Raspberry Pi

$ sudo raspi-config
Open the Raspberry Pi configuration screen

$ raspistill -o <file>.jpg
Take a photo and save it as <file>.jpg

Apt & Aptitude

$ apt-get install <package-name>
Install <package-name> using apt

$ aptitude install <package-name>
Install <package-name> using aptitude

$ aptitude search <name>
Search for package with <name> in name or metadata

Two Hello Worlds

A “Hello, World!” program is a very basic program that outputs the words “Hello, World!” on a screen.
It’s often used to illustrate the basic syntax of a program, and to prove that we can run a script or compile code on a computer.

You can run a variety of programming languages on the Raspberry Pi.

Generally speaking there are two types of programming languages, interpreted (sometimes called scripting languages) and compiled languages.

Some examples of interpreted programming languages included on our Raspberry Pi:

• Perl
• PHP
• Python
• Ruby
• Javascript

Compiled Programming Languages:

• C
• Java

In this workshop we’re going to use the programming languages Ruby (a dynamic, open source programming language with a focus on simplicity and productivity) and a little bit of C (a programming language developed way back in 1969 at Bell Labs).

Writing your first Programming Script

Open Leafpad on your Raspberry Pi and create a new file.
Save the file as hello_world.rb in your home directory.
In the file enter the line:

  puts "Hello, World!"

Now Save the file again. This is our first Ruby Script!

Running our program

To run our program we need to open our Shell Terminal.
One the terminal is open, to run our script

We can run our script by typing ruby hello_world.rb.

Nice work, you’ve just run your first program!

We could do the same thing in the Python programming language by creating a file called hello_world.py and entering the code:

    print('Hello, World!') 

Using which to show where a program is

When we were running the above commands we’re asking the Ruby or Python interpreter to read the file called hello_world.rb or hello_world.py and run the code.

These interpreters are programs in their own right (often written in “C”).

We can find out where these interpreters are living by typing in our terminal which ruby or which python.

When you run this you should see something like: /usr/bin/ruby.
This means that the Ruby interpreter (a file called ruby) is in a folder called bin within a folder called user on the top level of our file system.

The bin directory is on our PATH. The PATH is a setting that tells the Linux shell which directories to search for executable files (e.g. our programming language interpreters such as Ruby and Python). The PATH lets us be lazy and just type: ruby hello_world.rb. Under the hood Linux is doing the same as us typing /usr/bin/ruby hello_world.rb.

If we’re really lazy and don’t want to even type the name of the interpreter each time we run the script, we can modify the script to tell the shell where the Ruby program is. E.g.

  #!/usr/bin/ruby

  puts 'Hello, World!'

or in Python

  #!/usr/bin/python

  print('Hello, World!') 

Open your hello_world.rb file and modify it to include the #!/usr/bin/ruby line.

Change file modes

On Linux, by default files aren’t setup to be ‘executeable’. This means we can’t just run them by typing out the name of the file. This is a good thing (for security reasons).

The interpreters on the other hand have been setup for us with the 'execute permissions’ enabled. This means that our user on the Raspberry Pi can run the Ruby and Python interpreters without having to do anything special.

If we want to make a file executable we need to use the chmod command to set the file mode.

We can do this with the command chmod +x hello_world.rb. The +x flag or parameter tells the chmod program that we want the file hello_world.rb to be executable.

Lets try running our file now with hello_world.rb, bummer it doesn’t work!
Why is this the case? To run the the hello_world.rb file we actually need to put ./ before the file name. I.e. ./hello_world.rb. This is because the folder that contains the hello_world.rb file isn’t part of our PATH.

Lets try running our file now with ./hello_world.rb.

The “Hello World” of Electronics

The quintessential “Hello World” of electronics is blinking an LED. To do this we need to hook up an LED and a resistor to our Raspberry Pi.

Hooking up the Electronics

Parts needed:

• Single Colour LED.
• 2 Jumper Wires

The LED (Light Emitting Diode)

An LED stands for (light emitting diode). As it’s name suggests it’s a two-lead semiconductor that can create a light source.

The most obvious parts of the LED are it’s epoxy cap and it’s two legs. If you look closely you’ll notice that one leg is shorter than the other. This is called the cathode (or negative terminal). Conversly, the longer leg is called the annode (or positive terminal).

Another way you can tell which side is the negative, is by feeling the epoxy cap. The edge with the flat side is the cathode.

Build Steps:

1. Connect a black jumper wire from the GND pin to the cathode of the LED.
2. Connect a red jumper wire from GPIO16 to the annode of the LED.

Installing our software dependencies

Now that we’ve setup the electronics, lets write some code to control the LED.
We’re going to do this in Ruby.

Ruby needs a library called pi_piper to talk to the GPIO.

pi_piper needs the Ruby development header files and SSL Development in order to be installed.
To install these we need to use the aptitude command line package management interface.
This is a tool built into Debian flavours of Linux (of which Raspbian is one of them).

Before we can use aptitude to install the development headers we must first resynchronize the package index files from their sources. We do this with the sudo apt-get update command.

You’ll notice that we’re using the sudo command in front of the apt-get command. This lets us escalate our privileges from that of the pi user to that of `root. We’re required to do this because we’re changing system wide settings.

To install the Ruby development header files type: sudo aptitude install ruby2.1-dev

Installing this package will use some space (a bit under 5MB) on our SD Card. The Linux OS is kind enough to ask us if we’re ok with that. Type Y to let it continue.

To install the SSL Development header files type: sudo aptitude install libssl-dev

Again, Linux will check with us whether it’s ok if it uses 3MB of space on our SD Card. Again, type Y to let it continue.

Now that we’ve got the development headers installed, we can now install pi_piper using Rubygems.
Rubygems is a library management system for Ruby software libraries (called Gems). A gem is simply a premade bundle of code that we can leverage in our own programs. There are gems from everything from talking to databases to sending SMSs.

To install a Ruby gem we use the gem command. Ruby ships with the gem command preinstalled.

To install the pi_piper gem we type: sudo gem install pi_piper. If we want a bit more feedback on what’s going on, we can add --verbose to the end of the command. I.e. sudo gem install pi_piper --verbose.

Again we’re using the sudo command, this time it’s in front of the gem command. This lets us escalate our privileges from that of the pi user to that of `root. We’re required to do this because we’re installing software that can be used by other users throughout the system.

Writing our code

Now that we have all the dependencies installed, we’re going to write our code.

Open Leafpad on your Raspberry Pi and create a new file.
Save the file as blink.rb in your home directory.
In the file enter the code:

    #!/usr/bin/ruby

    require 'rubygems' 
    require 'pi_piper'

    pin = PiPiper::Pin.new(:pin => 16, :direction => :out)

    pin.on
    sleep 1
    pin.off

Save the file.

Just as with the hello_world.rb file we’re going to need to make this executable by using chmod. We do this with the command chmod +x blink.rb .

To run the script type: sudo blink.rb . If everything works correctly you should see the LED blink once. You’ve just completed the electronics “Hello, World!”.

Rain Alert Indicator

Now that we’ve got the skills to turn on and off an LED. Lets put these skills into action by building a project that will turn on the LED if it’s going to rain today.

Scraping a website

In order to get the weather data, we’re going to scrape the Bureau of Meteorology website.
We’re going to need some more Ruby gems to do this, specifically httparty and nokogiri.
httparty lets us do HTTP requests, just like our web browsers do and nokogiri lets us parse the HTML documents that are web pages.

Lets install them with the command:

sudo gem install httparty nokogiri --verbose

Writing the code

Once again, open Leafpad on your Raspberry Pi and create a new file.
Save the file as weather.rb in your home directory.
In the file enter the code:

  #!/usr/bin/env ruby

  require 'rubygems'

  # Require the HTTParty Gem for doing web requests
  require 'httparty'

  # Require the Nokogiri gem for searching through web pages. 
  require 'nokogiri'

  # Require the Pipiper gem for talking to the GPIO.
  require 'pi_piper' 

  # Define our LED pin 16
  led = PiPiper::Pin.new(:pin => 16, :direction => :out)
  led.off # Turn off our LED just incase it was left on

  # Fetch the page from the BOM
  bom_url = 'http://www.bom.gov.au/vic/forecasts/melbourne.shtml'
  page = HTTParty.get(bom_url).body

  # Parse the HTML to Nokogiri
  doc = Nokogiri::HTML(page)

  # This next line of code is doing three things:
  #   1) Search the webpage for the first node with a class 
  #      called 'forecast'
  #   2) Search this node for the class 'summary'
  #   3) Assign the contents of this HTML node to a new variable 
  #      called forecast

  forecast = doc.search('.forecast').first.search('.summary').inner_html

  # If the text includes 'showers', it's going to rain. 
  # So turn on the LED.

  if forecast.downcase.include? 'showers'
    puts "It's going to rain today. Turn on the LED"
    led.on # Turn on our led
  else
    puts "It's NOT going to rain today. Turn off the LED"
      led.off # Turn on our led
  end

  loop do 
    sleep 1 # Keep the script running forever! 
  end

Save the file.

Just as with all our other scripts, we’re going to need to make this file executable by using chmod. We do this with the command chmod +x weather.rb .

To run the script type: sudo weather.rb . If everything works correctly, and if it’s raining in Melbourne (hey it’s Melbourne so the odds are good), you should see in the terminal It's going to rain today. Turn on the LED and the LED should turn on.

Creating Scheduled Tasks with Cron

Running the weather.rb command mannually every time we want to know the weather, can get a little boring over time. It’d be much better if we could have our Raspberry Pi automatically fetch the weather every 5 minutes from the BOM. We can do this with Cron. Cron is a daemon (background process) to execute scheduled commands. The scheduled commands are called cron-jobs.

To create a new cron-job as they’re called, type crontab -e.
When you do this cron is going to ask you what command line text editor you’d like to use to edit the cron file.

  pi@raspberrypi:~ $ crontab -e
  no crontab for pi - using an empty one

  Select an editor.  To change later, run 'select-editor'.
    1. /bin/ed
    2. /bin/nano        <---- easiest
    3. /usr/bin/vim.tiny

  Choose 1-3 [2]:

We’re going to use a command line text editor called nano as it’s the easiest to use, and the default on Raspbian.

To select nano press the return key.

Press the down arrow key until you’re at the bottom of the file and enter the line:

*/5 * * * * sudo pkill ruby; sudo /home/pi/weather.rb >/dev/null 2>&1

Press ctl + O and then return to save the file.
Press ctl + x to exit nano.

A handy tool for creating the Crontab lines is http://crontab-generator.org

Creating a Smart Door Bell

The Raspberry Pi is a great little device for home automation.
In this project we’re going to create a smart door bell.

To make a “smart” door bell it needs to at the very least:

• Read the input of a button
• Play a sound
• Perform some other action (such as sending an email)

… lets look at these in detail.

Connecting a button to a Raspberry Pi

Up until now, we’ve focused solely on controlling an output by blinking an LED.
Now we’re going to jump to the other end of the spectrum and play around with push buttons.
For our push button, we’re going to use an button. This button is going to be hooked up to our Raspberry Pi such that when the button is pushed, the voltage goes HIGH. Some Ruby code we’ll write will read this and react accordingly.

Hooking up the Electronics

Parts needed:

• 1x Push Button
• 1x Red Jumper Wire
• 1x Black Jumper Wire

Build Steps:

1. Connect a red jumper wire from 3V3 to the power rail.
2. Connect a black jumper wire from GND to the ground rail.
3. Connect the yellow wire from one of the button’s pins to GPIO17.
4. Connect the black wire from the button to the ground rail.

Ruby Code

    #!/usr/bin/env ruby
    require 'rubygems'
    require 'pi_piper'

    pin = PiPiper::Pin.new(:pin => 17, :direction => :in, :pull => :up)

    loop do
      puts pin.read
      sleep 0.1
    end

Playing sounds on the command-line

Every door bell needs a “ding-dong” sound. Little Bird has uploaded a “ding-dong” sound which you can download from our site using wget.

To download the file type: wget https://cdn.shopify.com/s/files/1/0851/3314/files/doorbell-1.wav

To play sound on the Raspberry Pi we use aplay a command-line player for the ALSA soundcard driver (the driver built into Raspbian). So to play our doorbell sound we run: aplay doorbell-1.wav .

If the sound is staticky/crackly, try increasing the volume output (counterintuitive I know…) with amixer. amixer is a command-line mixer, again for the ALSA soundcard driver. A level that worked for me was 80%. I.e. amixer set 'PCM' 80% .

Making a Sound when the push button is pressed

Now that we know how to tell when a button is pressed, and know how to play a sound we can make a functioning door bell with the following code:

    #!/usr/bin/env ruby
    require 'rubygems'
    require 'pi_piper'

    pin = PiPiper::Pin.new(:pin => 17, :direction => :in, :pull => :up)

    loop do
      puts pin.read
      if pin.read == 0
        `aplay doorbell-1.wav` 
      end
      sleep 0.1
    end

    #!/usr/bin/env ruby
    require 'rubygems'
    require 'pi_piper'
    include PiPiper

    after :pin => 17, :goes => :high do
      puts "Button pressed"
      `aplay doorbell-1.wav` 
    end

    PiPiper.wait

Code to note

Ruby allows us to run shell commands within a script using backticks (’`’). The line:

    `aplay doorbell-1.wav` 

is really just doing the same aplay doorbell-1.wav command we ran earlier.

Getting an Email alert when a button is pressed

Homework for when you get home

Ok, so now we’ve got a working door bell, time to make it smart!
To make it smart lets add email functionality with the pony gem that lets you send text and HTML email.

The pony gem is installed like any other gem with sudo gem install pony --verbose.

    #!/usr/bin/env ruby
    require 'rubygems'
    require 'pi_piper'
    require 'pony'
    include PiPiper


    after :pin => 17, :goes => :high do
      puts "Button pressed"
      `aplay doorbell-1.wav` 
      current_time = Time.now.strftime("%d/%m/%Y %H:%M")

      Pony.mail({
         :to => "example@gmail.com",
         :body => "Somebody pressed the door bell at #{current_time}",
         :subject => "Door Bell Alert!",
         :via => :smtp,
         :via_options => {
           :address              => 'smtp.gmail.com',
           :port                 => '587',
           :enable_starttls_auto => true,
           :user_name            => "example@gmail.com",
           :password             => 'SECRET',
           :authentication       => :plain, 
           :domain               => "localhost.localdomain"
                      }
        })

    end

    PiPiper.wait

If you’re using Gmail or Google Apps for your email service, you might need to allow your account to provide access to less secure apps.

Creating a game controller

Now that we know how to tell when push buttons are pressed, with just a little bit more knowledge we can do interesting things like building custom games controllers.

xdotool

To create our custom game controller we need a system that can simulate keyboard input and mouse activity.

A command-line X11 automation tool called xdotool can do just this.

To install xdotool we’re again going to use aptitude: sudo aptitude install xdotool .
Now that xdotool we can simulate key strokes.

To simulate pressing the ‘a’ key we would run xdotool key a
To simulate pressing the 'left’ key we would run xdotool key Left
To simulate pressing the 'right’ key we would run xdotool key Right

Left/Right controller

Hooking up the Electronics

Parts needed:

• 2x Arcade Push Button
• 1x Red Jumper Wire
• 1x Black Jumper Wire

Build Steps:

You should already have your first button setup from the smart doorbell exercise.
All we need to do is add another button by:

1. Connect the red wire from the button to the power rail.
2. Connect the black wire from the button to the ground rail.
3. Connect the green wire from the button to GPIO27

Ruby Code

We already know how to run shell commands from our Ruby scripts. We just did it with the door bell. So just swap out the aplay command for the xdotool command inside our button code blocks.

    #!/usr/bin/env ruby

    require 'rubygems'
    require 'pi_piper'
    include PiPiper


    left = PiPiper::Pin.new(:pin => 17, :direction => :in, :pull => :up)
    right = PiPiper::Pin.new(:pin => 27, :direction => :in, :pull => :up)

    loop do
        if left.read == 0
           puts "Left button pressed"
           `xdotool key Left`
        end

        if right.read == 0
          puts "Right button pressed"
          `xdotool key Right`
        end

    end

Testing our controller

Now that we have a custom controller lets test it with a game.

Click the Raspberry Pi Menu and select Games → Python Games.

Select your default audio output.

Select tetrominoforidiots.

Fire up controller.rb and click on the “Tetromino for Idiots” window.

Click away like a mouse on crack.

Using Analogue Sensors

In this project we’re going to connect an analogue sensor (a Photo Resistor) to our Raspberry Pi.

Analogue Vs Digital

Circuits are usually divided into three categories - analogue circuits, digital circuits, or mixed-signal circuits.

The circuits we’ve built so far a digital circuits, that are they really only have two levels, high/low (for our buttons) or on/off (for our LEDs). In contrast analogue circuits have signals that are continuously variable voltage.

About Photo Resistors

In this circuit, you’ll be using a photo resistor, which changes resistance based on how much light the sensor receives.

In order to be able to measure this resistance, we need to overcome two challenges.

1. Unlike an Arduino, our Raspberry Pi can’t actually read analogue signals. It doesn’t have an ADC (analogue-to-digital converter) on board. To get round this we’re going to use the MCP3008, an external ADC that we can communicate with digitally via SPI (Serial Peripheral Interface).
2. Our MCP3008 can’t directly interpret resistance (rather, it reads voltage), so we’re going to use a voltage divider to measure the resistance change. This voltage divider will output a high voltage when it is getting a lot of light and a low voltage when it is not.

Voltage Dividers

Many of the sensors you’ll use (potentiometers, photo resistors, etc.) are resistors in disguise. Their resistance changes in proportion to whatever they’re sensing (light level, temperature, sound, etc.).

A voltage divider consists of two resistors. The “top” resistor is the sensor you’ll be using. The “bottom” one is a normal, fixed resistor. When you connect the top resistor to 3.3 volts, and the bottom resistor to ground. The voltage at the middle will be proportional to the bottom resistor relative to the total resistance (top resistor + bottom resistor). When one of the resistors changes (as it will when your sensor senses things), the output voltage will change as well!

Hooking up the MCP3008

In order to read analog data we need to use the following pins:

• VDD (power)
• DGND (digital ground) to power the MCP3008 chip.

We also need four “SPI” data pins:

• DOUT (Data Out from MCP3008)
• CLK (Clock pin)
• DIN (Data In from Raspberry Pi)
• CS (Chip Select)

The MCP3008 has a few more pins we need to connect:

• AGND (analog ground, used sometimes in precision circuitry, which this is not)
• VREF (analog voltage reference, used for changing the “scale” - we want the full scale, so tie it to 3.3V).

Finally of course, a source of analog data. A line from our voltage divider.

Build Steps:

1. Hook the left power rail to 3.3V (red)
2. Hook the left ground rail to GND (black)
3. Connect MCP3008 VDD -> 3.3V (red)
4. MCP3008 VDD -> 3.3V rail (red)
5. MCP3008 VREF -> 3.3V rail (red)
6. MCP3008 AGND -> GND rail (black)
7. MCP3008 CLK -> GPIO18 (yellow)
8. MCP3008 DOUT -> GPIO23 (green)
9. MCP3008 DIN -> GPIO24 (blue)
10. MCP3008 CS -> GPIO25 (yellow)
11. MCP3008 DGND -> GND (black)

Hooking up the Photo Resistor

Now that we’ve got our MCP3008 setup, we need to create a voltage divider and run a line from it to the MCP3008’s CH0.

Build Steps:

1. Connect 1 leg of the photo resistor to GND rail (black)
2. Connect 1 leg of the photo resistor to the 10K resistor
3. Connect 1 leg of the 10K resistor to 3.3V (red)
4. Run a line from between the photo resistor and the resistor to MCP3008 CH0

Photo Resistor Code

    #!/usr/bin/env ruby

    require 'rubygems'
    require 'pi_piper'

    #port of the Adafruit MCP3008 interface code found @ http://learn.adafruit.com/send-raspberry-pi-data-to-cosm/python-script
    # Modified from https://github.com/jwhitehorn/pi_piper/blob/master/examples/mcp3008/mcp3008.rb

    def read_adc(adc_pin, clockpin, adc_in, adc_out, cspin)
      cspin.on
      clockpin.off
      cspin.off

      command_out = adc_pin
      command_out |= 0x18
      command_out <<= 3

      (0..4).each do
        adc_in.update_value((command_out & 0x80) > 0)
        command_out <<= 1
        clockpin.on
        clockpin.off
      end
      result = 0

      (0..11).each do
        clockpin.on
        clockpin.off
        result <<= 1
        adc_out.read
        if adc_out.on?
          result |= 0x1
        end
      end

      cspin.on

      result >> 1
    end

    clock = PiPiper::Pin.new :pin => 18, :direction => :out
    adc_out = PiPiper::Pin.new :pin => 23
    adc_in = PiPiper::Pin.new :pin => 24, :direction => :out
    cs = PiPiper::Pin.new :pin => 25, :direction => :out

    adc_pin = 0

    loop do
      value = read_adc(adc_pin, clock, adc_in, adc_out, cs)
      invert = 1023 - value
      mvolts = invert * (3300.0 / 1023.0)
      puts "Value = #{value}, invert = #{invert}, mvolts = #{mvolts}"
      sleep 1
    end

Just as with all our other scripts, we’re going to need to make this executable by using chmod. We do this with the command chmod +x adc.rb .

To run the script type: sudo adc.rb . If everything works correctly, you should see in the terminal Value = 92, invert = 931, mvolts = 3003.2258064516127 (the values should be changing depending on the amount of light on the photo resistor).

Making a Weather Station

In this project we’re going to turn our Raspberry Pi into a weather station.
We’re going to present the live weather data (temperature and humidity) in a web application that we can access via the web.

The sensor we’re going to use is the DHT11 humidity and temperature sensor.

We’re going to take this as a learning opportunity to expose you to:

• Downloading code
• Compiling C code from source - the translation of source code into object code by a compiler

Hooking up the DHT22

Build Steps:

1. Connect GND pin of the DHT22 to a GND pin
2. Connect VCC pin of the DHT22 to the 3V3 pin
3. Connect the Signal pin of the DHT22 to GPIO 4

Fetching and expanding the C library for Broadcom BCM 28XX

Make a directory for our project

mkdir weather

cd weather

Download the library with wget

wget http://www.airspayce.com/mikem/bcm2835/bcm2835-1.50.tar.gz

Extract the library

tar -xvf ./bcm2835-1.50.tar.gz

Change into the bcm2835-1.50 directory

cd bcm2835-1.50

Compile and install the C code

sudo configure

sudo make

sudo make install

Installing the DHT Sensor FFI GEM

sudo gem install dht-sensor-ffi --verbose --no-ri --no-rdoc

Running a WebServer

Install sinatra
sudo gem install sinatra --verbose --no-ri --no-rdoc

The code:

#!/usr/bin/env ruby

require 'rubygems'
require 'sinatra'
require "dht-sensor-ffi"


get '/' do
    val = DhtSensor.read(4, 22) # pin=4, sensor type=DHT-22
    puts val.temp               # => 21.89 (temp in C)
    puts val.temp_f             # => 71.41 (temp in F)
    puts val.humidity           # => 22.70 (relative humidity %)
    "Temp: #{val.temp.round(2)} Humidity: #{val.humidity.round(2)}"
end

Make app.rb executable
chmod +x ./app.rb

Run app.rb
sudo ./app.rb

Get your Raspberry Pi’s IP address with
ifconfig

Visit your Raspberry Pi’s IP address in a browser.